1

node_modules/terser-webpack-plugin/dist/index.js

@@ -0,0 +1,707 @@
+"use strict";
+
+const os = require("os");
+const path = require("path");
+const {
+  validate
+} = require("schema-utils");
+const {
+  minify
+} = require("./minify");
+const schema = require("./options.json");
+const {
+  esbuildMinify,
+  memoize,
+  swcMinify,
+  terserMinify,
+  throttleAll,
+  uglifyJsMinify
+} = require("./utils");
+
+/** @typedef {import("schema-utils/declarations/validate").Schema} Schema */
+/** @typedef {import("webpack").Compiler} Compiler */
+/** @typedef {import("webpack").Compilation} Compilation */
+/** @typedef {import("webpack").Configuration} Configuration */
+/** @typedef {import("webpack").Asset} Asset */
+/** @typedef {import("webpack").AssetInfo} AssetInfo */
+/** @typedef {import("webpack").TemplatePath} TemplatePath */
+/** @typedef {import("jest-worker").Worker} JestWorker */
+/** @typedef {import("@jridgewell/trace-mapping").EncodedSourceMap & { sources: string[], sourcesContent?: string[], file: string }} RawSourceMap */
+/** @typedef {import("@jridgewell/trace-mapping").TraceMap} TraceMap */
+
+/** @typedef {RegExp | string} Rule */
+/** @typedef {Rule[] | Rule} Rules */
+
+// eslint-disable-next-line jsdoc/reject-any-type
+/** @typedef {any} EXPECTED_ANY */
+
+/**
+ * @callback ExtractCommentsFunction
+ * @param {EXPECTED_ANY} astNode ast Node
+ * @param {{ value: string, type: "comment1" | "comment2" | "comment3" | "comment4", pos: number, line: number, col: number }} comment comment node
+ * @returns {boolean} true when need to extract comment, otherwise false
+ */
+
+/**
+ * @typedef {boolean | "all" | "some" | RegExp | ExtractCommentsFunction} ExtractCommentsCondition
+ */
+
+/**
+ * @typedef {TemplatePath} ExtractCommentsFilename
+ */
+
+/**
+ * @typedef {boolean | string | ((commentsFile: string) => string)} ExtractCommentsBanner
+ */
+
+/**
+ * @typedef {object} ExtractCommentsObject
+ * @property {ExtractCommentsCondition=} condition condition which comments need to be expected
+ * @property {ExtractCommentsFilename=} filename filename for extracted comments
+ * @property {ExtractCommentsBanner=} banner banner in filename for extracted comments
+ */
+
+/**
+ * @typedef {ExtractCommentsCondition | ExtractCommentsObject} ExtractCommentsOptions
+ */
+
+/**
+ * @typedef {object} ErrorObject
+ * @property {string} message message
+ * @property {number=} line line number
+ * @property {number=} column column number
+ * @property {string=} stack error stack trace
+ */
+
+/**
+ * @typedef {object} MinimizedResult
+ * @property {string=} code code
+ * @property {RawSourceMap=} map source map
+ * @property {(Error | string)[]=} errors errors
+ * @property {(Error | string)[]=} warnings warnings
+ * @property {string[]=} extractedComments extracted comments
+ */
+
+/**
+ * @typedef {{ [file: string]: string }} Input
+ */
+
+/**
+ * @typedef {{ [key: string]: EXPECTED_ANY }} CustomOptions
+ */
+
+/**
+ * @template T
+ * @typedef {T extends infer U ? U : CustomOptions} InferDefaultType
+ */
+
+/**
+ * @template T
+ * @typedef {object} PredefinedOptions
+ * @property {T extends { module?: infer P } ? P : boolean | string=} module true when code is a EC module, otherwise false
+ * @property {T extends { ecma?: infer P } ? P : number | string=} ecma ecma version
+ */
+
+/**
+ * @template T
+ * @typedef {PredefinedOptions<T> & InferDefaultType<T>} MinimizerOptions
+ */
+
+/**
+ * @template T
+ * @callback BasicMinimizerImplementation
+ * @param {Input} input
+ * @param {RawSourceMap | undefined} sourceMap
+ * @param {MinimizerOptions<T>} minifyOptions
+ * @param {ExtractCommentsOptions | undefined} extractComments
+ * @returns {Promise<MinimizedResult> | MinimizedResult}
+ */
+
+/**
+ * @typedef {object} MinimizeFunctionHelpers
+ * @property {() => string | undefined=} getMinimizerVersion function that returns version of minimizer
+ * @property {() => boolean | undefined=} supportsWorkerThreads true when minimizer support worker threads, otherwise false
+ */
+
+/**
+ * @template T
+ * @typedef {BasicMinimizerImplementation<T> & MinimizeFunctionHelpers} MinimizerImplementation
+ */
+
+/**
+ * @template T
+ * @typedef {object} InternalOptions
+ * @property {string} name name
+ * @property {string} input input
+ * @property {RawSourceMap | undefined} inputSourceMap input source map
+ * @property {ExtractCommentsOptions | undefined} extractComments extract comments option
+ * @property {{ implementation: MinimizerImplementation<T>, options: MinimizerOptions<T> }} minimizer minimizer
+ */
+
+/**
+ * @template T
+ * @typedef {JestWorker & { transform: (options: string) => Promise<MinimizedResult>, minify: (options: InternalOptions<T>) => Promise<MinimizedResult> }} MinimizerWorker
+ */
+
+/**
+ * @typedef {undefined | boolean | number} Parallel
+ */
+
+/**
+ * @typedef {object} BasePluginOptions
+ * @property {Rules=} test test rule
+ * @property {Rules=} include include rile
+ * @property {Rules=} exclude exclude rule
+ * @property {ExtractCommentsOptions=} extractComments extract comments options
+ * @property {Parallel=} parallel parallel option
+ */
+
+/**
+ * @template T
+ * @typedef {T extends import("terser").MinifyOptions ? { minify?: MinimizerImplementation<T> | undefined, terserOptions?: MinimizerOptions<T> | undefined } : { minify: MinimizerImplementation<T>, terserOptions?: MinimizerOptions<T> | undefined }} DefinedDefaultMinimizerAndOptions
+ */
+
+/**
+ * @template T
+ * @typedef {BasePluginOptions & { minimizer: { implementation: MinimizerImplementation<T>, options: MinimizerOptions<T> } }} InternalPluginOptions
+ */
+
+const getTraceMapping = memoize(() => require("@jridgewell/trace-mapping"));
+const getSerializeJavascript = memoize(() => require("./serialize-javascript"));
+
+/**
+ * @template [T=import("terser").MinifyOptions]
+ */
+class TerserPlugin {
+  /**
+   * @param {BasePluginOptions & DefinedDefaultMinimizerAndOptions<T>=} options options
+   */
+  constructor(options) {
+    validate(/** @type {Schema} */schema, options || {}, {
+      name: "Terser Plugin",
+      baseDataPath: "options"
+    });
+
+    // TODO make `minimizer` option instead `minify` and `terserOptions` in the next major release, also rename `terserMinify` to `terserMinimize`
+    const {
+      minify = (/** @type {MinimizerImplementation<T>} */terserMinify),
+      terserOptions = (/** @type {MinimizerOptions<T>} */{}),
+      test = /\.[cm]?js(\?.*)?$/i,
+      extractComments = true,
+      parallel = true,
+      include,
+      exclude
+    } = options || {};
+
+    /**
+     * @private
+     * @type {InternalPluginOptions<T>}
+     */
+    this.options = {
+      test,
+      extractComments,
+      parallel,
+      include,
+      exclude,
+      minimizer: {
+        implementation: minify,
+        options: terserOptions
+      }
+    };
+  }
+
+  /**
+   * @private
+   * @param {unknown} input Input to check
+   * @returns {boolean} Whether input is a source map
+   */
+  static isSourceMap(input) {
+    // All required options for `new TraceMap(...options)`
+    // https://github.com/jridgewell/trace-mapping#usage
+    return Boolean(input && typeof input === "object" && input !== null && "version" in input && "sources" in input && Array.isArray(input.sources) && "mappings" in input && typeof input.mappings === "string");
+  }
+
+  /**
+   * @private
+   * @param {unknown} warning warning
+   * @param {string} file file
+   * @returns {Error} built warning
+   */
+  static buildWarning(warning, file) {
+    /**
+     * @type {Error & { hideStack: true, file: string }}
+     */
+    // @ts-expect-error
+    const builtWarning = new Error(warning.toString());
+    builtWarning.name = "Warning";
+    builtWarning.hideStack = true;
+    builtWarning.file = file;
+    return builtWarning;
+  }
+
+  /**
+   * @private
+   * @param {Error | ErrorObject | string} error error
+   * @param {string} file file
+   * @param {TraceMap=} sourceMap source map
+   * @param {Compilation["requestShortener"]=} requestShortener request shortener
+   * @returns {Error} built error
+   */
+  static buildError(error, file, sourceMap, requestShortener) {
+    /**
+     * @type {Error & { file?: string }}
+     */
+    let builtError;
+    if (typeof error === "string") {
+      builtError = new Error(`${file} from Terser plugin\n${error}`);
+      builtError.file = file;
+      return builtError;
+    }
+    if (/** @type {ErrorObject} */error.line) {
+      const {
+        line,
+        column
+      } = /** @type {ErrorObject & { line: number, column: number }} */error;
+      const original = sourceMap && getTraceMapping().originalPositionFor(sourceMap, {
+        line,
+        column
+      });
+      if (original && original.source && requestShortener) {
+        builtError = new Error(`${file} from Terser plugin\n${error.message} [${requestShortener.shorten(original.source)}:${original.line},${original.column}][${file}:${line},${column}]${error.stack ? `\n${error.stack.split("\n").slice(1).join("\n")}` : ""}`);
+        builtError.file = file;
+        return builtError;
+      }
+      builtError = new Error(`${file} from Terser plugin\n${error.message} [${file}:${line},${column}]${error.stack ? `\n${error.stack.split("\n").slice(1).join("\n")}` : ""}`);
+      builtError.file = file;
+      return builtError;
+    }
+    if (error.stack) {
+      builtError = new Error(`${file} from Terser plugin\n${typeof error.message !== "undefined" ? error.message : ""}\n${error.stack}`);
+      builtError.file = file;
+      return builtError;
+    }
+    builtError = new Error(`${file} from Terser plugin\n${error.message}`);
+    builtError.file = file;
+    return builtError;
+  }
+
+  /**
+   * @private
+   * @param {Parallel} parallel value of the `parallel` option
+   * @returns {number} number of cores for parallelism
+   */
+  static getAvailableNumberOfCores(parallel) {
+    // In some cases cpus() returns undefined
+    // https://github.com/nodejs/node/issues/19022
+    const cpus =
+    // eslint-disable-next-line n/no-unsupported-features/node-builtins
+    typeof os.availableParallelism === "function" ?
+    // eslint-disable-next-line n/no-unsupported-features/node-builtins
+    {
+      length: os.availableParallelism()
+    } : os.cpus() || {
+      length: 1
+    };
+    return parallel === true || typeof parallel === "undefined" ? cpus.length - 1 : Math.min(parallel || 0, cpus.length - 1);
+  }
+
+  /**
+   * @private
+   * @param {Compiler} compiler compiler
+   * @param {Compilation} compilation compilation
+   * @param {Record<string, import("webpack").sources.Source>} assets assets
+   * @param {{ availableNumberOfCores: number }} optimizeOptions optimize options
+   * @returns {Promise<void>}
+   */
+  async optimize(compiler, compilation, assets, optimizeOptions) {
+    const cache = compilation.getCache("TerserWebpackPlugin");
+    let numberOfAssets = 0;
+    const assetsForMinify = await Promise.all(Object.keys(assets).filter(name => {
+      const {
+        info
+      } = /** @type {Asset} */compilation.getAsset(name);
+      if (
+      // Skip double minimize assets from child compilation
+      info.minimized ||
+      // Skip minimizing for extracted comments assets
+      info.extractedComments) {
+        return false;
+      }
+      if (!compiler.webpack.ModuleFilenameHelpers.matchObject.bind(undefined, this.options)(name)) {
+        return false;
+      }
+      return true;
+    }).map(async name => {
+      const {
+        info,
+        source
+      } = /** @type {Asset} */
+      compilation.getAsset(name);
+      const eTag = cache.getLazyHashedEtag(source);
+      const cacheItem = cache.getItemCache(name, eTag);
+      const output = await cacheItem.getPromise();
+      if (!output) {
+        numberOfAssets += 1;
+      }
+      return {
+        name,
+        info,
+        inputSource: source,
+        output,
+        cacheItem
+      };
+    }));
+    if (assetsForMinify.length === 0) {
+      return;
+    }
+
+    /** @type {undefined | (() => MinimizerWorker<T>)} */
+    let getWorker;
+    /** @type {undefined | MinimizerWorker<T>} */
+    let initializedWorker;
+    /** @type {undefined | number} */
+    let numberOfWorkers;
+    if (optimizeOptions.availableNumberOfCores > 0) {
+      // Do not create unnecessary workers when the number of files is less than the available cores, it saves memory
+      numberOfWorkers = Math.min(numberOfAssets, optimizeOptions.availableNumberOfCores);
+      getWorker = () => {
+        if (initializedWorker) {
+          return initializedWorker;
+        }
+        const {
+          Worker
+        } = require("jest-worker");
+        initializedWorker = /** @type {MinimizerWorker<T>} */
+
+        new Worker(require.resolve("./minify"), {
+          numWorkers: numberOfWorkers,
+          enableWorkerThreads: typeof this.options.minimizer.implementation.supportsWorkerThreads !== "undefined" ? this.options.minimizer.implementation.supportsWorkerThreads() !== false : true
+        });
+
+        // https://github.com/facebook/jest/issues/8872#issuecomment-524822081
+        const workerStdout = initializedWorker.getStdout();
+        if (workerStdout) {
+          workerStdout.on("data", chunk => process.stdout.write(chunk));
+        }
+        const workerStderr = initializedWorker.getStderr();
+        if (workerStderr) {
+          workerStderr.on("data", chunk => process.stderr.write(chunk));
+        }
+        return initializedWorker;
+      };
+    }
+    const {
+      SourceMapSource,
+      ConcatSource,
+      RawSource
+    } = compiler.webpack.sources;
+
+    /** @typedef {{ extractedCommentsSource: import("webpack").sources.RawSource, commentsFilename: string }} ExtractedCommentsInfo */
+    /** @type {Map<string, ExtractedCommentsInfo>} */
+    const allExtractedComments = new Map();
+    const scheduledTasks = [];
+    for (const asset of assetsForMinify) {
+      scheduledTasks.push(async () => {
+        const {
+          name,
+          inputSource,
+          info,
+          cacheItem
+        } = asset;
+        let {
+          output
+        } = asset;
+        if (!output) {
+          let input;
+          /** @type {RawSourceMap | undefined} */
+          let inputSourceMap;
+          const {
+            source: sourceFromInputSource,
+            map
+          } = inputSource.sourceAndMap();
+          input = sourceFromInputSource;
+          if (map) {
+            if (!TerserPlugin.isSourceMap(map)) {
+              compilation.warnings.push(new Error(`${name} contains invalid source map`));
+            } else {
+              inputSourceMap = /** @type {RawSourceMap} */map;
+            }
+          }
+          if (Buffer.isBuffer(input)) {
+            input = input.toString();
+          }
+
+          /**
+           * @type {InternalOptions<T>}
+           */
+          const options = {
+            name,
+            input,
+            inputSourceMap,
+            minimizer: {
+              implementation: this.options.minimizer.implementation,
+              options: {
+                ...this.options.minimizer.options
+              }
+            },
+            extractComments: this.options.extractComments
+          };
+          if (typeof options.minimizer.options.module === "undefined") {
+            if (typeof info.javascriptModule !== "undefined") {
+              options.minimizer.options.module = /** @type {PredefinedOptions<T>["module"]} */
+              info.javascriptModule;
+            } else if (/\.mjs(\?.*)?$/i.test(name)) {
+              options.minimizer.options.module = /** @type {PredefinedOptions<T>["module"]} */true;
+            } else if (/\.cjs(\?.*)?$/i.test(name)) {
+              options.minimizer.options.module = /** @type {PredefinedOptions<T>["module"]} */false;
+            }
+          }
+          if (typeof options.minimizer.options.ecma === "undefined") {
+            options.minimizer.options.ecma = /** @type {PredefinedOptions<T>["ecma"]} */
+
+            TerserPlugin.getEcmaVersion(compiler.options.output.environment || {});
+          }
+          try {
+            output = await (getWorker ? getWorker().transform(getSerializeJavascript()(options)) : minify(options));
+          } catch (error) {
+            const hasSourceMap = inputSourceMap && TerserPlugin.isSourceMap(inputSourceMap);
+            compilation.errors.push(TerserPlugin.buildError(/** @type {Error | ErrorObject | string} */
+            error, name, hasSourceMap ? new (getTraceMapping().TraceMap)(/** @type {RawSourceMap} */
+            inputSourceMap) : undefined, hasSourceMap ? compilation.requestShortener : undefined));
+            return;
+          }
+          if (typeof output.code === "undefined") {
+            compilation.errors.push(new Error(`${name} from Terser plugin\nMinimizer doesn't return result`));
+          }
+          if (output.warnings && output.warnings.length > 0) {
+            output.warnings = output.warnings.map(
+            /**
+             * @param {Error | string} item a warning
+             * @returns {Error} built warning with extra info
+             */
+            item => TerserPlugin.buildWarning(item, name));
+          }
+          if (output.errors && output.errors.length > 0) {
+            const hasSourceMap = inputSourceMap && TerserPlugin.isSourceMap(inputSourceMap);
+            output.errors = output.errors.map(
+            /**
+             * @param {Error | string} item an error
+             * @returns {Error} built error with extra info
+             */
+            item => TerserPlugin.buildError(item, name, hasSourceMap ? new (getTraceMapping().TraceMap)(/** @type {RawSourceMap} */
+            inputSourceMap) : undefined, hasSourceMap ? compilation.requestShortener : undefined));
+          }
+
+          // Custom functions can return `undefined` or `null`
+          if (typeof output.code !== "undefined" && output.code !== null) {
+            let shebang;
+            if (/** @type {ExtractCommentsObject} */
+            this.options.extractComments.banner !== false && output.extractedComments && output.extractedComments.length > 0 && output.code.startsWith("#!")) {
+              const firstNewlinePosition = output.code.indexOf("\n");
+              shebang = output.code.slice(0, Math.max(0, firstNewlinePosition));
+              output.code = output.code.slice(Math.max(0, firstNewlinePosition + 1));
+            }
+            if (output.map) {
+              output.source = new SourceMapSource(output.code, name, output.map, input, /** @type {RawSourceMap} */
+              inputSourceMap, true);
+            } else {
+              output.source = new RawSource(output.code);
+            }
+            if (output.extractedComments && output.extractedComments.length > 0) {
+              const commentsFilename = /** @type {ExtractCommentsObject} */
+              this.options.extractComments.filename || "[file].LICENSE.txt[query]";
+              let query = "";
+              let filename = name;
+              const querySplit = filename.indexOf("?");
+              if (querySplit >= 0) {
+                query = filename.slice(querySplit);
+                filename = filename.slice(0, querySplit);
+              }
+              const lastSlashIndex = filename.lastIndexOf("/");
+              const basename = lastSlashIndex === -1 ? filename : filename.slice(lastSlashIndex + 1);
+              const data = {
+                filename,
+                basename,
+                query
+              };
+              output.commentsFilename = compilation.getPath(commentsFilename, data);
+              let banner;
+
+              // Add a banner to the original file
+              if (/** @type {ExtractCommentsObject} */
+              this.options.extractComments.banner !== false) {
+                banner = /** @type {ExtractCommentsObject} */
+                this.options.extractComments.banner || `For license information please see ${path.relative(path.dirname(name), output.commentsFilename).replace(/\\/g, "/")}`;
+                if (typeof banner === "function") {
+                  banner = banner(output.commentsFilename);
+                }
+                if (banner) {
+                  output.source = new ConcatSource(shebang ? `${shebang}\n` : "", `/*! ${banner} */\n`, output.source);
+                }
+              }
+              const extractedCommentsString = output.extractedComments.sort().join("\n\n");
+              output.extractedCommentsSource = new RawSource(`${extractedCommentsString}\n`);
+            }
+          }
+          await cacheItem.storePromise({
+            source: output.source,
+            errors: output.errors,
+            warnings: output.warnings,
+            commentsFilename: output.commentsFilename,
+            extractedCommentsSource: output.extractedCommentsSource
+          });
+        }
+        if (output.warnings && output.warnings.length > 0) {
+          for (const warning of output.warnings) {
+            compilation.warnings.push(warning);
+          }
+        }
+        if (output.errors && output.errors.length > 0) {
+          for (const error of output.errors) {
+            compilation.errors.push(error);
+          }
+        }
+        if (!output.source) {
+          return;
+        }
+
+        /** @type {AssetInfo} */
+        const newInfo = {
+          minimized: true
+        };
+        const {
+          source,
+          extractedCommentsSource
+        } = output;
+
+        // Write extracted comments to commentsFilename
+        if (extractedCommentsSource) {
+          const {
+            commentsFilename
+          } = output;
+          newInfo.related = {
+            license: commentsFilename
+          };
+          allExtractedComments.set(name, {
+            extractedCommentsSource,
+            commentsFilename
+          });
+        }
+        compilation.updateAsset(name, source, newInfo);
+      });
+    }
+    const limit = getWorker && numberOfAssets > 0 ? (/** @type {number} */numberOfWorkers) : scheduledTasks.length;
+    await throttleAll(limit, scheduledTasks);
+    if (initializedWorker) {
+      await initializedWorker.end();
+    }
+
+    /** @typedef {{ source: import("webpack").sources.Source, commentsFilename: string, from: string }} ExtractedCommentsInfoWithFrom */
+    await [...allExtractedComments].sort().reduce(
+    /**
+     * @param {Promise<unknown>} previousPromise previous result
+     * @param {[string, ExtractedCommentsInfo]} extractedComments extracted comments
+     * @returns {Promise<ExtractedCommentsInfoWithFrom>} extract comments with info
+     */
+    async (previousPromise, [from, value]) => {
+      const previous = /** @type {ExtractedCommentsInfoWithFrom | undefined} * */
+      await previousPromise;
+      const {
+        commentsFilename,
+        extractedCommentsSource
+      } = value;
+      if (previous && previous.commentsFilename === commentsFilename) {
+        const {
+          from: previousFrom,
+          source: prevSource
+        } = previous;
+        const mergedName = `${previousFrom}|${from}`;
+        const name = `${commentsFilename}|${mergedName}`;
+        const eTag = [prevSource, extractedCommentsSource].map(item => cache.getLazyHashedEtag(item)).reduce((previousValue, currentValue) => cache.mergeEtags(previousValue, currentValue));
+        let source = await cache.getPromise(name, eTag);
+        if (!source) {
+          source = new ConcatSource([...new Set([... /** @type {string} */prevSource.source().split("\n\n"), ... /** @type {string} */extractedCommentsSource.source().split("\n\n")])].join("\n\n"));
+          await cache.storePromise(name, eTag, source);
+        }
+        compilation.updateAsset(commentsFilename, source);
+        return {
+          source,
+          commentsFilename,
+          from: mergedName
+        };
+      }
+      const existingAsset = compilation.getAsset(commentsFilename);
+      if (existingAsset) {
+        return {
+          source: existingAsset.source,
+          commentsFilename,
+          from: commentsFilename
+        };
+      }
+      compilation.emitAsset(commentsFilename, extractedCommentsSource, {
+        extractedComments: true
+      });
+      return {
+        source: extractedCommentsSource,
+        commentsFilename,
+        from
+      };
+    }, /** @type {Promise<unknown>} */Promise.resolve());
+  }
+
+  /**
+   * @private
+   * @param {NonNullable<NonNullable<Configuration["output"]>["environment"]>} environment environment
+   * @returns {number} ecma version
+   */
+  static getEcmaVersion(environment) {
+    // ES 6th
+    if (environment.arrowFunction || environment.const || environment.destructuring || environment.forOf || environment.module) {
+      return 2015;
+    }
+
+    // ES 11th
+    if (environment.bigIntLiteral || environment.dynamicImport) {
+      return 2020;
+    }
+    return 5;
+  }
+
+  /**
+   * @param {Compiler} compiler compiler
+   * @returns {void}
+   */
+  apply(compiler) {
+    const pluginName = this.constructor.name;
+    const availableNumberOfCores = TerserPlugin.getAvailableNumberOfCores(this.options.parallel);
+    compiler.hooks.compilation.tap(pluginName, compilation => {
+      const hooks = compiler.webpack.javascript.JavascriptModulesPlugin.getCompilationHooks(compilation);
+      const data = getSerializeJavascript()({
+        minimizer: typeof this.options.minimizer.implementation.getMinimizerVersion !== "undefined" ? this.options.minimizer.implementation.getMinimizerVersion() || "0.0.0" : "0.0.0",
+        options: this.options.minimizer.options
+      });
+      hooks.chunkHash.tap(pluginName, (chunk, hash) => {
+        hash.update("TerserPlugin");
+        hash.update(data);
+      });
+      compilation.hooks.processAssets.tapPromise({
+        name: pluginName,
+        stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE,
+        additionalAssets: true
+      }, assets => this.optimize(compiler, compilation, assets, {
+        availableNumberOfCores
+      }));
+      compilation.hooks.statsPrinter.tap(pluginName, stats => {
+        stats.hooks.print.for("asset.info.minimized").tap("terser-webpack-plugin", (minimized, {
+          green,
+          formatFlag
+        }) => minimized ? /** @type {(text: string) => string} */green(/** @type {(flag: string) => string} */formatFlag("minimized")) : "");
+      });
+    });
+  }
+}
+TerserPlugin.terserMinify = terserMinify;
+TerserPlugin.uglifyJsMinify = uglifyJsMinify;
+TerserPlugin.swcMinify = swcMinify;
+TerserPlugin.esbuildMinify = esbuildMinify;
+module.exports = TerserPlugin;

node_modules/terser-webpack-plugin/dist/minify.js

@@ -0,0 +1,49 @@
+"use strict";
+
+/** @typedef {import("./index.js").MinimizedResult} MinimizedResult */
+/** @typedef {import("./index.js").CustomOptions} CustomOptions */
+
+/**
+ * @template T
+ * @param {import("./index.js").InternalOptions<T>} options options
+ * @returns {Promise<MinimizedResult>} minified result
+ */
+async function minify(options) {
+  const {
+    name,
+    input,
+    inputSourceMap,
+    extractComments
+  } = options;
+  const {
+    implementation,
+    options: minimizerOptions
+  } = options.minimizer;
+  return implementation({
+    [name]: input
+  }, inputSourceMap, minimizerOptions, extractComments);
+}
+
+/**
+ * @param {string} options options
+ * @returns {Promise<MinimizedResult>} minified result
+ */
+async function transform(options) {
+  // 'use strict' => this === undefined (Clean Scope)
+  // Safer for possible security issues, albeit not critical at all here
+
+  const evaluatedOptions =
+  /**
+   * @template T
+   * @type {import("./index.js").InternalOptions<T>}
+   */
+
+  // eslint-disable-next-line no-new-func
+  new Function("exports", "require", "module", "__filename", "__dirname", `'use strict'\nreturn ${options}`) // eslint-disable-next-line n/exports-style
+  (exports, require, module, __filename, __dirname);
+  return minify(evaluatedOptions);
+}
+module.exports = {
+  minify,
+  transform
+};

node_modules/terser-webpack-plugin/dist/options.json

@@ -0,0 +1,164 @@
+{
+  "definitions": {
+    "Rule": {
+      "description": "Filtering rule as regex or string.",
+      "anyOf": [
+        {
+          "instanceof": "RegExp",
+          "tsType": "RegExp"
+        },
+        {
+          "type": "string",
+          "minLength": 1
+        }
+      ]
+    },
+    "Rules": {
+      "description": "Filtering rules.",
+      "anyOf": [
+        {
+          "type": "array",
+          "items": {
+            "description": "A rule condition.",
+            "oneOf": [
+              {
+                "$ref": "#/definitions/Rule"
+              }
+            ]
+          }
+        },
+        {
+          "$ref": "#/definitions/Rule"
+        }
+      ]
+    }
+  },
+  "title": "TerserPluginOptions",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "test": {
+      "description": "Include all modules that pass test assertion.",
+      "link": "https://github.com/webpack/terser-webpack-plugin#test",
+      "oneOf": [
+        {
+          "$ref": "#/definitions/Rules"
+        }
+      ]
+    },
+    "include": {
+      "description": "Include all modules matching any of these conditions.",
+      "link": "https://github.com/webpack/terser-webpack-plugin#include",
+      "oneOf": [
+        {
+          "$ref": "#/definitions/Rules"
+        }
+      ]
+    },
+    "exclude": {
+      "description": "Exclude all modules matching any of these conditions.",
+      "link": "https://github.com/webpack/terser-webpack-plugin#exclude",
+      "oneOf": [
+        {
+          "$ref": "#/definitions/Rules"
+        }
+      ]
+    },
+    "terserOptions": {
+      "description": "Options for `terser` (by default) or custom `minify` function.",
+      "link": "https://github.com/webpack/terser-webpack-plugin#terseroptions",
+      "additionalProperties": true,
+      "type": "object"
+    },
+    "extractComments": {
+      "description": "Whether comments shall be extracted to a separate file.",
+      "link": "https://github.com/webpack/terser-webpack-plugin#extractcomments",
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "string",
+          "minLength": 1
+        },
+        {
+          "instanceof": "RegExp"
+        },
+        {
+          "instanceof": "Function"
+        },
+        {
+          "additionalProperties": false,
+          "properties": {
+            "condition": {
+              "anyOf": [
+                {
+                  "type": "boolean"
+                },
+                {
+                  "type": "string",
+                  "minLength": 1
+                },
+                {
+                  "instanceof": "RegExp"
+                },
+                {
+                  "instanceof": "Function"
+                }
+              ],
+              "description": "Condition what comments you need extract.",
+              "link": "https://github.com/webpack/terser-webpack-plugin#condition"
+            },
+            "filename": {
+              "anyOf": [
+                {
+                  "type": "string",
+                  "minLength": 1
+                },
+                {
+                  "instanceof": "Function"
+                }
+              ],
+              "description": "The file where the extracted comments will be stored. Default is to append the suffix .LICENSE.txt to the original filename.",
+              "link": "https://github.com/webpack/terser-webpack-plugin#filename"
+            },
+            "banner": {
+              "anyOf": [
+                {
+                  "type": "boolean"
+                },
+                {
+                  "type": "string",
+                  "minLength": 1
+                },
+                {
+                  "instanceof": "Function"
+                }
+              ],
+              "description": "The banner text that points to the extracted file and will be added on top of the original file",
+              "link": "https://github.com/webpack/terser-webpack-plugin#banner"
+            }
+          },
+          "type": "object"
+        }
+      ]
+    },
+    "parallel": {
+      "description": "Use multi-process parallel running to improve the build speed.",
+      "link": "https://github.com/webpack/terser-webpack-plugin#parallel",
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "integer"
+        }
+      ]
+    },
+    "minify": {
+      "description": "Allows you to override default minify function.",
+      "link": "https://github.com/webpack/terser-webpack-plugin#number",
+      "instanceof": "Function"
+    }
+  }
+}

node_modules/terser-webpack-plugin/dist/serialize-javascript.js

@@ -0,0 +1,278 @@
+"use strict";
+
+// @ts-nocheck
+
+var g = typeof globalThis !== 'undefined' ? globalThis : global;
+var crypto = g.crypto || {};
+if (typeof crypto.getRandomValues !== 'function') {
+  var nodeCrypto = require('crypto');
+  crypto.getRandomValues = function (typedArray) {
+    var bytes = nodeCrypto.randomBytes(typedArray.byteLength);
+    new Uint8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength).set(bytes);
+    return typedArray;
+  };
+}
+/*
+Copyright (c) 2014, Yahoo! Inc. All rights reserved.
+Copyrights licensed under the New BSD License.
+See the accompanying LICENSE file for terms.
+*/
+
+'use strict';
+
+// Generate an internal UID to make the regexp pattern harder to guess.
+var UID_LENGTH = 16;
+var UID = generateUID();
+var PLACE_HOLDER_REGEXP = new RegExp('(\\\\)?"@__(F|R|D|M|S|A|U|I|B|L)-' + UID + '-(\\d+)__@"', 'g');
+var IS_NATIVE_CODE_REGEXP = /\{\s*\[native code\]\s*\}/g;
+var IS_PURE_FUNCTION = /function.*?\(/;
+var IS_ARROW_FUNCTION = /.*?=>.*?/;
+var UNSAFE_CHARS_REGEXP = /[<>\/\u2028\u2029]/g;
+// Regex to match </script> and variations (case-insensitive) for XSS protection
+// Matches </script followed by optional whitespace/attributes and >
+var SCRIPT_CLOSE_REGEXP = /<\/script[^>]*>/gi;
+var RESERVED_SYMBOLS = ['*', 'async'];
+
+// Mapping of unsafe HTML and invalid JavaScript line terminator chars to their
+// Unicode char counterparts which are safe to use in JavaScript strings.
+var ESCAPED_CHARS = {
+  '<': '\\u003C',
+  '>': '\\u003E',
+  '/': '\\u002F',
+  '\u2028': '\\u2028',
+  '\u2029': '\\u2029'
+};
+function escapeUnsafeChars(unsafeChar) {
+  return ESCAPED_CHARS[unsafeChar];
+}
+
+// Escape function body for XSS protection while preserving arrow function syntax
+function escapeFunctionBody(str) {
+  // Escape </script> sequences and variations (case-insensitive) - the main XSS risk
+  // Matches </script followed by optional whitespace/attributes and >
+  // This must be done first before other replacements
+  str = str.replace(SCRIPT_CLOSE_REGEXP, function (match) {
+    // Escape all <, /, and > characters in the closing script tag
+    return match.replace(/</g, '\\u003C').replace(/\//g, '\\u002F').replace(/>/g, '\\u003E');
+  });
+  // Escape line terminators (these are always unsafe)
+  str = str.replace(/\u2028/g, '\\u2028');
+  str = str.replace(/\u2029/g, '\\u2029');
+  return str;
+}
+function generateUID() {
+  var bytes = crypto.getRandomValues(new Uint8Array(UID_LENGTH));
+  var result = '';
+  for (var i = 0; i < UID_LENGTH; ++i) {
+    result += bytes[i].toString(16);
+  }
+  return result;
+}
+function deleteFunctions(obj) {
+  var functionKeys = [];
+  for (var key in obj) {
+    if (typeof obj[key] === "function") {
+      functionKeys.push(key);
+    }
+  }
+  for (var i = 0; i < functionKeys.length; i++) {
+    delete obj[functionKeys[i]];
+  }
+}
+module.exports = function serialize(obj, options) {
+  options || (options = {});
+
+  // Backwards-compatibility for `space` as the second argument.
+  if (typeof options === 'number' || typeof options === 'string') {
+    options = {
+      space: options
+    };
+  }
+  var functions = [];
+  var regexps = [];
+  var dates = [];
+  var maps = [];
+  var sets = [];
+  var arrays = [];
+  var undefs = [];
+  var infinities = [];
+  var bigInts = [];
+  var urls = [];
+
+  // Returns placeholders for functions and regexps (identified by index)
+  // which are later replaced by their string representation.
+  function replacer(key, value) {
+    // For nested function
+    if (options.ignoreFunction) {
+      deleteFunctions(value);
+    }
+    if (!value && value !== undefined && value !== BigInt(0)) {
+      return value;
+    }
+
+    // If the value is an object w/ a toJSON method, toJSON is called before
+    // the replacer runs, so we use this[key] to get the non-toJSONed value.
+    var origValue = this[key];
+    var type = typeof origValue;
+    if (type === 'object') {
+      if (origValue instanceof RegExp) {
+        return '@__R-' + UID + '-' + (regexps.push(origValue) - 1) + '__@';
+      }
+      if (origValue instanceof Date) {
+        return '@__D-' + UID + '-' + (dates.push(origValue) - 1) + '__@';
+      }
+      if (origValue instanceof Map) {
+        return '@__M-' + UID + '-' + (maps.push(origValue) - 1) + '__@';
+      }
+      if (origValue instanceof Set) {
+        return '@__S-' + UID + '-' + (sets.push(origValue) - 1) + '__@';
+      }
+      if (origValue instanceof Array) {
+        var isSparse = origValue.filter(function () {
+          return true;
+        }).length !== origValue.length;
+        if (isSparse) {
+          return '@__A-' + UID + '-' + (arrays.push(origValue) - 1) + '__@';
+        }
+      }
+      if (origValue instanceof URL) {
+        return '@__L-' + UID + '-' + (urls.push(origValue) - 1) + '__@';
+      }
+    }
+    if (type === 'function') {
+      return '@__F-' + UID + '-' + (functions.push(origValue) - 1) + '__@';
+    }
+    if (type === 'undefined') {
+      return '@__U-' + UID + '-' + (undefs.push(origValue) - 1) + '__@';
+    }
+    if (type === 'number' && !isNaN(origValue) && !isFinite(origValue)) {
+      return '@__I-' + UID + '-' + (infinities.push(origValue) - 1) + '__@';
+    }
+    if (type === 'bigint') {
+      return '@__B-' + UID + '-' + (bigInts.push(origValue) - 1) + '__@';
+    }
+    return value;
+  }
+  function serializeFunc(fn, options) {
+    var serializedFn = fn.toString();
+    if (IS_NATIVE_CODE_REGEXP.test(serializedFn)) {
+      throw new TypeError('Serializing native function: ' + fn.name);
+    }
+
+    // Escape unsafe HTML characters in function body for XSS protection
+    // This must preserve arrow function syntax (=>) while escaping </script>
+    if (options && options.unsafe !== true) {
+      serializedFn = escapeFunctionBody(serializedFn);
+    }
+
+    // pure functions, example: {key: function() {}}
+    if (IS_PURE_FUNCTION.test(serializedFn)) {
+      return serializedFn;
+    }
+
+    // arrow functions, example: arg1 => arg1+5
+    if (IS_ARROW_FUNCTION.test(serializedFn)) {
+      return serializedFn;
+    }
+    var argsStartsAt = serializedFn.indexOf('(');
+    var def = serializedFn.substr(0, argsStartsAt).trim().split(' ').filter(function (val) {
+      return val.length > 0;
+    });
+    var nonReservedSymbols = def.filter(function (val) {
+      return RESERVED_SYMBOLS.indexOf(val) === -1;
+    });
+
+    // enhanced literal objects, example: {key() {}}
+    if (nonReservedSymbols.length > 0) {
+      return (def.indexOf('async') > -1 ? 'async ' : '') + 'function' + (def.join('').indexOf('*') > -1 ? '*' : '') + serializedFn.substr(argsStartsAt);
+    }
+
+    // arrow functions
+    return serializedFn;
+  }
+
+  // Check if the parameter is function
+  if (options.ignoreFunction && typeof obj === "function") {
+    obj = undefined;
+  }
+  // Protects against `JSON.stringify()` returning `undefined`, by serializing
+  // to the literal string: "undefined".
+  if (obj === undefined) {
+    return String(obj);
+  }
+  var str;
+
+  // Creates a JSON string representation of the value.
+  // NOTE: Node 0.12 goes into slow mode with extra JSON.stringify() args.
+  if (options.isJSON && !options.space) {
+    str = JSON.stringify(obj);
+  } else {
+    str = JSON.stringify(obj, options.isJSON ? null : replacer, options.space);
+  }
+
+  // Protects against `JSON.stringify()` returning `undefined`, by serializing
+  // to the literal string: "undefined".
+  if (typeof str !== 'string') {
+    return String(str);
+  }
+
+  // Replace unsafe HTML and invalid JavaScript line terminator chars with
+  // their safe Unicode char counterpart. This _must_ happen before the
+  // regexps and functions are serialized and added back to the string.
+  if (options.unsafe !== true) {
+    str = str.replace(UNSAFE_CHARS_REGEXP, escapeUnsafeChars);
+  }
+  if (functions.length === 0 && regexps.length === 0 && dates.length === 0 && maps.length === 0 && sets.length === 0 && arrays.length === 0 && undefs.length === 0 && infinities.length === 0 && bigInts.length === 0 && urls.length === 0) {
+    return str;
+  }
+
+  // Replaces all occurrences of function, regexp, date, map and set placeholders in the
+  // JSON string with their string representations. If the original value can
+  // not be found, then `undefined` is used.
+  return str.replace(PLACE_HOLDER_REGEXP, function (match, backSlash, type, valueIndex) {
+    // The placeholder may not be preceded by a backslash. This is to prevent
+    // replacing things like `"a\"@__R-<UID>-0__@"` and thus outputting
+    // invalid JS.
+    if (backSlash) {
+      return match;
+    }
+    if (type === 'D') {
+      // Validate ISO string format to prevent code injection via spoofed toISOString()
+      var isoStr = String(dates[valueIndex].toISOString());
+      if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z$/.test(isoStr)) {
+        throw new TypeError('Invalid Date ISO string');
+      }
+      return "new Date(\"" + isoStr + "\")";
+    }
+    if (type === 'R') {
+      // Sanitize flags to prevent code injection (only allow valid RegExp flag characters)
+      var flags = String(regexps[valueIndex].flags).replace(/[^gimsuydv]/g, '');
+      return "new RegExp(" + serialize(regexps[valueIndex].source) + ", \"" + flags + "\")";
+    }
+    if (type === 'M') {
+      return "new Map(" + serialize(Array.from(maps[valueIndex].entries()), options) + ")";
+    }
+    if (type === 'S') {
+      return "new Set(" + serialize(Array.from(sets[valueIndex].values()), options) + ")";
+    }
+    if (type === 'A') {
+      return "Array.prototype.slice.call(" + serialize(Object.assign({
+        length: arrays[valueIndex].length
+      }, arrays[valueIndex]), options) + ")";
+    }
+    if (type === 'U') {
+      return 'undefined';
+    }
+    if (type === 'I') {
+      return infinities[valueIndex];
+    }
+    if (type === 'B') {
+      return "BigInt(\"" + bigInts[valueIndex] + "\")";
+    }
+    if (type === 'L') {
+      return "new URL(" + serialize(urls[valueIndex].toString(), options) + ")";
+    }
+    var fn = functions[valueIndex];
+    return serializeFunc(fn, options);
+  });
+};

node_modules/terser-webpack-plugin/dist/utils.js

@@ -0,0 +1,678 @@
+"use strict";
+
+/** @typedef {import("./index.js").ExtractCommentsOptions} ExtractCommentsOptions */
+/** @typedef {import("./index.js").ExtractCommentsFunction} ExtractCommentsFunction */
+/** @typedef {import("./index.js").ExtractCommentsCondition} ExtractCommentsCondition */
+/** @typedef {import("./index.js").Input} Input */
+/** @typedef {import("./index.js").MinimizedResult} MinimizedResult */
+/** @typedef {import("./index.js").CustomOptions} CustomOptions */
+/** @typedef {import("./index.js").RawSourceMap} RawSourceMap */
+
+/**
+ * @template T
+ * @typedef {import("./index.js").PredefinedOptions<T>} PredefinedOptions
+ */
+
+/**
+ * @typedef {string[]} ExtractedComments
+ */
+
+const notSettled = Symbol("not-settled");
+
+/**
+ * @template T
+ * @typedef {() => Promise<T>} Task
+ */
+
+/**
+ * Run tasks with limited concurrency.
+ * @template T
+ * @param {number} limit Limit of tasks that run at once.
+ * @param {Task<T>[]} tasks List of tasks to run.
+ * @returns {Promise<T[]>} A promise that fulfills to an array of the results
+ */
+function throttleAll(limit, tasks) {
+  return new Promise((resolve, reject) => {
+    const result = Array.from({
+      length: tasks.length
+    }).fill(notSettled);
+    const entries = tasks.entries();
+    const next = () => {
+      const {
+        done,
+        value
+      } = entries.next();
+      if (done) {
+        const isLast = !result.includes(notSettled);
+        if (isLast) resolve(result);
+        return;
+      }
+      const [index, task] = value;
+
+      /**
+       * @param {T} resultValue Result value
+       */
+      const onFulfilled = resultValue => {
+        result[index] = resultValue;
+        next();
+      };
+      task().then(onFulfilled, reject);
+    };
+    for (let i = 0; i < limit; i++) {
+      next();
+    }
+  });
+}
+
+/* istanbul ignore next */
+/**
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map
+ * @param {CustomOptions=} minimizerOptions options
+ * @param {ExtractCommentsOptions=} extractComments extract comments option
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+async function terserMinify(input, sourceMap, minimizerOptions, extractComments) {
+  // eslint-disable-next-line jsdoc/no-restricted-syntax
+  /**
+   * @param {unknown} value value
+   * @returns {value is object} true when value is object or function
+   */
+  const isObject = value => {
+    const type = typeof value;
+
+    // eslint-disable-next-line no-eq-null, eqeqeq
+    return value != null && (type === "object" || type === "function");
+  };
+
+  /**
+   * @param {import("terser").MinifyOptions & { sourceMap: import("terser").SourceMapOptions | undefined } & ({ output: import("terser").FormatOptions & { beautify: boolean } } | { format: import("terser").FormatOptions & { beautify: boolean } })} terserOptions terser options
+   * @param {ExtractedComments} extractedComments extracted comments
+   * @returns {ExtractCommentsFunction} function to extract comments
+   */
+  const buildComments = (terserOptions, extractedComments) => {
+    /** @type {{ [index: string]: ExtractCommentsCondition }} */
+    const condition = {};
+    let comments;
+    if (terserOptions.format) {
+      ({
+        comments
+      } = terserOptions.format);
+    } else if (terserOptions.output) {
+      ({
+        comments
+      } = terserOptions.output);
+    }
+    condition.preserve = typeof comments !== "undefined" ? comments : false;
+    if (typeof extractComments === "boolean" && extractComments) {
+      condition.extract = "some";
+    } else if (typeof extractComments === "string" || extractComments instanceof RegExp) {
+      condition.extract = extractComments;
+    } else if (typeof extractComments === "function") {
+      condition.extract = extractComments;
+    } else if (extractComments && isObject(extractComments)) {
+      condition.extract = typeof extractComments.condition === "boolean" && extractComments.condition ? "some" : typeof extractComments.condition !== "undefined" ? extractComments.condition : "some";
+    } else {
+      // No extract
+      // Preserve using "commentsOpts" or "some"
+      condition.preserve = typeof comments !== "undefined" ? comments : "some";
+      condition.extract = false;
+    }
+
+    // Ensure that both conditions are functions
+    for (const key of ["preserve", "extract"]) {
+      /** @type {undefined | string} */
+      let regexStr;
+      /** @type {undefined | RegExp} */
+      let regex;
+      switch (typeof condition[key]) {
+        case "boolean":
+          condition[key] = condition[key] ? () => true : () => false;
+          break;
+        case "function":
+          break;
+        case "string":
+          if (condition[key] === "all") {
+            condition[key] = () => true;
+            break;
+          }
+          if (condition[key] === "some") {
+            condition[key] = /** @type {ExtractCommentsFunction} */
+            (astNode, comment) => (comment.type === "comment2" || comment.type === "comment1") && /@preserve|@lic|@cc_on|^\**!/i.test(comment.value);
+            break;
+          }
+          regexStr = /** @type {string} */condition[key];
+          condition[key] = /** @type {ExtractCommentsFunction} */
+          (astNode, comment) => new RegExp(/** @type {string} */regexStr).test(comment.value);
+          break;
+        default:
+          regex = /** @type {RegExp} */condition[key];
+          condition[key] = /** @type {ExtractCommentsFunction} */
+          (astNode, comment) => /** @type {RegExp} */regex.test(comment.value);
+      }
+    }
+
+    // Redefine the comments function to extract and preserve
+    // comments according to the two conditions
+    return (astNode, comment) => {
+      if (/** @type {{ extract: ExtractCommentsFunction }} */
+      condition.extract(astNode, comment)) {
+        const commentText = comment.type === "comment2" ? `/*${comment.value}*/` : `//${comment.value}`;
+
+        // Don't include duplicate comments
+        if (!extractedComments.includes(commentText)) {
+          extractedComments.push(commentText);
+        }
+      }
+      return /** @type {{ preserve: ExtractCommentsFunction }} */condition.preserve(astNode, comment);
+    };
+  };
+
+  /**
+   * @param {PredefinedOptions<import("terser").MinifyOptions> & import("terser").MinifyOptions=} terserOptions terser options
+   * @returns {import("terser").MinifyOptions & { sourceMap: import("terser").SourceMapOptions | undefined } & { compress: import("terser").CompressOptions } & ({ output: import("terser").FormatOptions & { beautify: boolean } } | { format: import("terser").FormatOptions & { beautify: boolean } })} built terser options
+   */
+  const buildTerserOptions = (terserOptions = {}) => (
+  // Need deep copy objects to avoid https://github.com/terser/terser/issues/366
+  {
+    ...terserOptions,
+    compress: typeof terserOptions.compress === "boolean" ? terserOptions.compress ? {} : false : {
+      ...terserOptions.compress
+    },
+    // ecma: terserOptions.ecma,
+    // ie8: terserOptions.ie8,
+    // keep_classnames: terserOptions.keep_classnames,
+    // keep_fnames: terserOptions.keep_fnames,
+    mangle:
+    // eslint-disable-next-line no-eq-null, eqeqeq
+    terserOptions.mangle == null ? true : typeof terserOptions.mangle === "boolean" ? terserOptions.mangle : {
+      ...terserOptions.mangle
+    },
+    // module: terserOptions.module,
+    // nameCache: { ...terserOptions.toplevel },
+    // the `output` option is deprecated
+    ...(terserOptions.format ? {
+      format: {
+        beautify: false,
+        ...terserOptions.format
+      }
+    } : {
+      output: {
+        beautify: false,
+        ...terserOptions.output
+      }
+    }),
+    parse: {
+      ...terserOptions.parse
+    },
+    // safari10: terserOptions.safari10,
+    // Ignoring sourceMap from options
+    sourceMap: undefined
+    // toplevel: terserOptions.toplevel
+  });
+  let minify;
+  try {
+    ({
+      minify
+    } = require("terser"));
+  } catch (err) {
+    return {
+      errors: [(/** @type {Error} */err)]
+    };
+  }
+
+  // Copy `terser` options
+  const terserOptions = buildTerserOptions(minimizerOptions);
+
+  // Let terser generate a SourceMap
+  if (sourceMap) {
+    terserOptions.sourceMap = {
+      asObject: true
+    };
+  }
+
+  /** @type {ExtractedComments} */
+  const extractedComments = [];
+  if (terserOptions.output) {
+    terserOptions.output.comments = buildComments(terserOptions, extractedComments);
+  } else if (terserOptions.format) {
+    terserOptions.format.comments = buildComments(terserOptions, extractedComments);
+  }
+  if (terserOptions.compress) {
+    // More optimizations
+    if (typeof terserOptions.compress.ecma === "undefined") {
+      terserOptions.compress.ecma = terserOptions.ecma;
+    }
+
+    // https://github.com/webpack/webpack/issues/16135
+    if (terserOptions.ecma === 5 && typeof terserOptions.compress.arrows === "undefined") {
+      terserOptions.compress.arrows = false;
+    }
+  }
+  const [[filename, code]] = Object.entries(input);
+  const result = await minify({
+    [filename]: code
+  }, terserOptions);
+  return {
+    code: (/** @type {string} * */result.code),
+    map: result.map ? (/** @type {RawSourceMap} * */result.map) : undefined,
+    extractedComments
+  };
+}
+
+/**
+ * @returns {string | undefined} the minimizer version
+ */
+terserMinify.getMinimizerVersion = () => {
+  let packageJson;
+  try {
+    packageJson = require("terser/package.json");
+  } catch (_err) {
+    // Ignore
+  }
+  return packageJson && packageJson.version;
+};
+
+/**
+ * @returns {boolean | undefined} true if worker thread is supported, false otherwise
+ */
+terserMinify.supportsWorkerThreads = () => true;
+
+/* istanbul ignore next */
+/**
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map
+ * @param {CustomOptions=} minimizerOptions options
+ * @param {ExtractCommentsOptions=} extractComments extract comments option
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+async function uglifyJsMinify(input, sourceMap, minimizerOptions, extractComments) {
+  // eslint-disable-next-line jsdoc/no-restricted-syntax
+  /**
+   * @param {unknown} value value
+   * @returns {value is object} true when value is object or function
+   */
+  const isObject = value => {
+    const type = typeof value;
+
+    // eslint-disable-next-line no-eq-null, eqeqeq
+    return value != null && (type === "object" || type === "function");
+  };
+
+  /**
+   * @param {import("uglify-js").MinifyOptions & { sourceMap: boolean | import("uglify-js").SourceMapOptions | undefined } & { output: import("uglify-js").OutputOptions & { beautify: boolean } }} uglifyJsOptions uglify-js options
+   * @param {ExtractedComments} extractedComments extracted comments
+   * @returns {ExtractCommentsFunction} extract comments function
+   */
+  const buildComments = (uglifyJsOptions, extractedComments) => {
+    /** @type {{ [index: string]: ExtractCommentsCondition }} */
+    const condition = {};
+    const {
+      comments
+    } = uglifyJsOptions.output;
+    condition.preserve = typeof comments !== "undefined" ? comments : false;
+    if (typeof extractComments === "boolean" && extractComments) {
+      condition.extract = "some";
+    } else if (typeof extractComments === "string" || extractComments instanceof RegExp) {
+      condition.extract = extractComments;
+    } else if (typeof extractComments === "function") {
+      condition.extract = extractComments;
+    } else if (extractComments && isObject(extractComments)) {
+      condition.extract = typeof extractComments.condition === "boolean" && extractComments.condition ? "some" : typeof extractComments.condition !== "undefined" ? extractComments.condition : "some";
+    } else {
+      // No extract
+      // Preserve using "commentsOpts" or "some"
+      condition.preserve = typeof comments !== "undefined" ? comments : "some";
+      condition.extract = false;
+    }
+
+    // Ensure that both conditions are functions
+    for (const key of ["preserve", "extract"]) {
+      /** @type {undefined | string} */
+      let regexStr;
+      /** @type {undefined | RegExp} */
+      let regex;
+      switch (typeof condition[key]) {
+        case "boolean":
+          condition[key] = condition[key] ? () => true : () => false;
+          break;
+        case "function":
+          break;
+        case "string":
+          if (condition[key] === "all") {
+            condition[key] = () => true;
+            break;
+          }
+          if (condition[key] === "some") {
+            condition[key] = /** @type {ExtractCommentsFunction} */
+            (astNode, comment) => (comment.type === "comment2" || comment.type === "comment1") && /@preserve|@lic|@cc_on|^\**!/i.test(comment.value);
+            break;
+          }
+          regexStr = /** @type {string} */condition[key];
+          condition[key] = /** @type {ExtractCommentsFunction} */
+          (astNode, comment) => new RegExp(/** @type {string} */regexStr).test(comment.value);
+          break;
+        default:
+          regex = /** @type {RegExp} */condition[key];
+          condition[key] = /** @type {ExtractCommentsFunction} */
+          (astNode, comment) => /** @type {RegExp} */regex.test(comment.value);
+      }
+    }
+
+    // Redefine the comments function to extract and preserve
+    // comments according to the two conditions
+    return (astNode, comment) => {
+      if (/** @type {{ extract: ExtractCommentsFunction }} */
+      condition.extract(astNode, comment)) {
+        const commentText = comment.type === "comment2" ? `/*${comment.value}*/` : `//${comment.value}`;
+
+        // Don't include duplicate comments
+        if (!extractedComments.includes(commentText)) {
+          extractedComments.push(commentText);
+        }
+      }
+      return /** @type {{ preserve: ExtractCommentsFunction }} */condition.preserve(astNode, comment);
+    };
+  };
+
+  /**
+   * @param {PredefinedOptions<import("uglify-js").MinifyOptions> & import("uglify-js").MinifyOptions=} uglifyJsOptions uglify-js options
+   * @returns {import("uglify-js").MinifyOptions & { sourceMap: boolean | import("uglify-js").SourceMapOptions | undefined } & { output: import("uglify-js").OutputOptions & { beautify: boolean } }} uglify-js options
+   */
+  const buildUglifyJsOptions = (uglifyJsOptions = {}) => {
+    if (typeof uglifyJsOptions.ecma !== "undefined") {
+      delete uglifyJsOptions.ecma;
+    }
+    if (typeof uglifyJsOptions.module !== "undefined") {
+      delete uglifyJsOptions.module;
+    }
+
+    // Need deep copy objects to avoid https://github.com/terser/terser/issues/366
+    return {
+      ...uglifyJsOptions,
+      // warnings: uglifyJsOptions.warnings,
+      parse: {
+        ...uglifyJsOptions.parse
+      },
+      compress: typeof uglifyJsOptions.compress === "boolean" ? uglifyJsOptions.compress : {
+        ...uglifyJsOptions.compress
+      },
+      mangle:
+      // eslint-disable-next-line no-eq-null, eqeqeq
+      uglifyJsOptions.mangle == null ? true : typeof uglifyJsOptions.mangle === "boolean" ? uglifyJsOptions.mangle : {
+        ...uglifyJsOptions.mangle
+      },
+      output: {
+        beautify: false,
+        ...uglifyJsOptions.output
+      },
+      // Ignoring sourceMap from options
+
+      sourceMap: undefined
+      // toplevel: uglifyJsOptions.toplevel
+      // nameCache: { ...uglifyJsOptions.toplevel },
+      // ie8: uglifyJsOptions.ie8,
+      // keep_fnames: uglifyJsOptions.keep_fnames,
+    };
+  };
+  let minify;
+  try {
+    ({
+      minify
+    } = require("uglify-js"));
+  } catch (err) {
+    return {
+      errors: [(/** @type {Error} */err)]
+    };
+  }
+
+  // Copy `uglify-js` options
+  const uglifyJsOptions = buildUglifyJsOptions(minimizerOptions);
+
+  // Let terser generate a SourceMap
+  if (sourceMap) {
+    uglifyJsOptions.sourceMap = true;
+  }
+
+  /** @type {ExtractedComments} */
+  const extractedComments = [];
+
+  // @ts-expect-error wrong types in uglify-js
+  uglifyJsOptions.output.comments = buildComments(uglifyJsOptions, extractedComments);
+  const [[filename, code]] = Object.entries(input);
+  const result = await minify({
+    [filename]: code
+  }, uglifyJsOptions);
+  return {
+    code: result.code,
+    map: result.map ? JSON.parse(result.map) : undefined,
+    errors: result.error ? [result.error] : [],
+    warnings: result.warnings || [],
+    extractedComments
+  };
+}
+
+/**
+ * @returns {string | undefined} the minimizer version
+ */
+uglifyJsMinify.getMinimizerVersion = () => {
+  let packageJson;
+  try {
+    packageJson = require("uglify-js/package.json");
+  } catch (_err) {
+    // Ignore
+  }
+  return packageJson && packageJson.version;
+};
+
+/**
+ * @returns {boolean | undefined} true if worker thread is supported, false otherwise
+ */
+uglifyJsMinify.supportsWorkerThreads = () => true;
+
+/* istanbul ignore next */
+/**
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map
+ * @param {CustomOptions=} minimizerOptions options
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+async function swcMinify(input, sourceMap, minimizerOptions) {
+  /**
+   * @param {PredefinedOptions<import("@swc/core").JsMinifyOptions> & import("@swc/core").JsMinifyOptions=} swcOptions swc options
+   * @returns {import("@swc/core").JsMinifyOptions & { sourceMap: undefined | boolean } & { compress: import("@swc/core").TerserCompressOptions }} built swc options
+   */
+  const buildSwcOptions = (swcOptions = {}) => (
+  // Need deep copy objects to avoid https://github.com/terser/terser/issues/366
+  {
+    ...swcOptions,
+    compress: typeof swcOptions.compress === "boolean" ? swcOptions.compress ? {} : false : {
+      ...swcOptions.compress
+    },
+    mangle:
+    // eslint-disable-next-line no-eq-null, eqeqeq
+    swcOptions.mangle == null ? true : typeof swcOptions.mangle === "boolean" ? swcOptions.mangle : {
+      ...swcOptions.mangle
+    },
+    // ecma: swcOptions.ecma,
+    // keep_classnames: swcOptions.keep_classnames,
+    // keep_fnames: swcOptions.keep_fnames,
+    // module: swcOptions.module,
+    // safari10: swcOptions.safari10,
+    // toplevel: swcOptions.toplevel
+
+    sourceMap: undefined
+  });
+  let swc;
+  try {
+    swc = require("@swc/core");
+  } catch (err) {
+    return {
+      errors: [(/** @type {Error} */err)]
+    };
+  }
+
+  // Copy `swc` options
+  const swcOptions = buildSwcOptions(minimizerOptions);
+
+  // Let `swc` generate a SourceMap
+  if (sourceMap) {
+    swcOptions.sourceMap = true;
+  }
+  if (swcOptions.compress) {
+    // More optimizations
+    if (typeof swcOptions.compress.ecma === "undefined") {
+      swcOptions.compress.ecma = swcOptions.ecma;
+    }
+
+    // https://github.com/webpack/webpack/issues/16135
+    if (swcOptions.ecma === 5 && typeof swcOptions.compress.arrows === "undefined") {
+      swcOptions.compress.arrows = false;
+    }
+  }
+  const [[filename, code]] = Object.entries(input);
+  const result = await swc.minify(code, swcOptions);
+  let map;
+  if (result.map) {
+    map = JSON.parse(result.map);
+
+    // TODO workaround for swc because `filename` is not preset as in `swc` signature as for `terser`
+    map.sources = [filename];
+    delete map.sourcesContent;
+  }
+  return {
+    code: result.code,
+    map
+  };
+}
+
+/**
+ * @returns {string | undefined} the minimizer version
+ */
+swcMinify.getMinimizerVersion = () => {
+  let packageJson;
+  try {
+    packageJson = require("@swc/core/package.json");
+  } catch (_err) {
+    // Ignore
+  }
+  return packageJson && packageJson.version;
+};
+
+/**
+ * @returns {boolean | undefined} true if worker thread is supported, false otherwise
+ */
+swcMinify.supportsWorkerThreads = () => false;
+
+/* istanbul ignore next */
+/**
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map
+ * @param {CustomOptions=} minimizerOptions options
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+async function esbuildMinify(input, sourceMap, minimizerOptions) {
+  /**
+   * @param {PredefinedOptions<import("esbuild").TransformOptions> & import("esbuild").TransformOptions=} esbuildOptions esbuild options
+   * @returns {import("esbuild").TransformOptions} built esbuild options
+   */
+  const buildEsbuildOptions = (esbuildOptions = {}) => {
+    delete esbuildOptions.ecma;
+    if (esbuildOptions.module) {
+      esbuildOptions.format = "esm";
+    }
+    delete esbuildOptions.module;
+
+    // Need deep copy objects to avoid https://github.com/terser/terser/issues/366
+    return {
+      minify: true,
+      legalComments: "inline",
+      ...esbuildOptions,
+      sourcemap: false
+    };
+  };
+  let esbuild;
+  try {
+    esbuild = require("esbuild");
+  } catch (err) {
+    return {
+      errors: [(/** @type {Error} */err)]
+    };
+  }
+
+  // Copy `esbuild` options
+  const esbuildOptions = buildEsbuildOptions(minimizerOptions);
+
+  // Let `esbuild` generate a SourceMap
+  if (sourceMap) {
+    esbuildOptions.sourcemap = true;
+    esbuildOptions.sourcesContent = false;
+  }
+  const [[filename, code]] = Object.entries(input);
+  esbuildOptions.sourcefile = filename;
+  const result = await esbuild.transform(code, esbuildOptions);
+  return {
+    code: result.code,
+    map: result.map ? JSON.parse(result.map) : undefined,
+    warnings: result.warnings.length > 0 ? result.warnings.map(item => {
+      const plugin = item.pluginName ? `\nPlugin Name: ${item.pluginName}` : "";
+      const location = item.location ? `\n\n${item.location.file}:${item.location.line}:${item.location.column}:\n  ${item.location.line} | ${item.location.lineText}\n\nSuggestion: ${item.location.suggestion}` : "";
+      const notes = item.notes.length > 0 ? `\n\nNotes:\n${item.notes.map(note => `${note.location ? `[${note.location.file}:${note.location.line}:${note.location.column}] ` : ""}${note.text}${note.location ? `\nSuggestion: ${note.location.suggestion}` : ""}${note.location ? `\nLine text:\n${note.location.lineText}\n` : ""}`).join("\n")}` : "";
+      return `${item.text} [${item.id}]${plugin}${location}${item.detail ? `\nDetails:\n${item.detail}` : ""}${notes}`;
+    }) : []
+  };
+}
+
+/**
+ * @returns {string | undefined} the minimizer version
+ */
+esbuildMinify.getMinimizerVersion = () => {
+  let packageJson;
+  try {
+    packageJson = require("esbuild/package.json");
+  } catch (_err) {
+    // Ignore
+  }
+  return packageJson && packageJson.version;
+};
+
+/**
+ * @returns {boolean | undefined} true if worker thread is supported, false otherwise
+ */
+esbuildMinify.supportsWorkerThreads = () => false;
+
+/**
+ * @template T
+ * @typedef {() => T} FunctionReturning
+ */
+
+/**
+ * @template T
+ * @param {FunctionReturning<T>} fn memorized function
+ * @returns {FunctionReturning<T>} new function
+ */
+function memoize(fn) {
+  let cache = false;
+  /** @type {T} */
+  let result;
+  return () => {
+    if (cache) {
+      return result;
+    }
+    result = fn();
+    cache = true;
+    // Allow to clean up memory for fn
+    // and all dependent resources
+    /** @type {FunctionReturning<T> | undefined} */
+    fn = undefined;
+    return /** @type {T} */result;
+  };
+}
+module.exports = {
+  esbuildMinify,
+  memoize,
+  swcMinify,
+  terserMinify,
+  throttleAll,
+  uglifyJsMinify
+};