Project Init

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

@@ -0,0 +1,765 @@
+"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 {
+  cleanCssMinify,
+  cssnanoMinify,
+  cssoMinify,
+  esbuildMinify,
+  esbuildMinifyCss,
+  getEcmaVersion,
+  htmlMinifierTerser,
+  jsonMinify,
+  lightningCssMinify,
+  memoize,
+  minifyHtmlNode,
+  swcMinify,
+  swcMinifyCss,
+  swcMinifyHtml,
+  swcMinifyHtmlFragment,
+  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").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 */
+// eslint-disable-next-line jsdoc/require-property
+/** @typedef {object} EXPECTED_OBJECT */
+
+/**
+ * @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 {T extends EXPECTED_ANY[] ? { [P in keyof T]?: T[P] & InferDefaultType<T[P]> } : 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
+ * @property {() => boolean | undefined=} supportsWorker true when minimizer support worker, otherwise false
+ * @property {(name: string, info?: AssetInfo) => boolean | undefined=} filter return true when the minimizer supports the asset, otherwise false. When an array of minimizers is configured, each asset is dispatched only to the minimizers whose `filter` accepts it. Assets rejected by every minimizer in the array are skipped entirely.
+ */
+
+/**
+ * @template T
+ * @typedef {T extends EXPECTED_ANY[] ? { [P in keyof T]: BasicMinimizerImplementation<T[P]> & MinimizeFunctionHelpers } : 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
+ * @property {boolean=} module true when code is a EC module, otherwise false
+ * @property {number | string=} ecma ecma version
+ */
+
+/**
+ * @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, minimizerOptions?: MinimizerOptions<T> | undefined, terserOptions?: MinimizerOptions<T> | undefined } : { minify: MinimizerImplementation<T>, minimizerOptions?: MinimizerOptions<T> | undefined, 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 handle json and etc in the next major release
+    // TODO make `minimizer` option instead `minify` and `terserOptions` in the next major release, also rename `terserMinify` to `terserMinimize`
+    const {
+      minify = (/** @type {MinimizerImplementation<T>} */
+      /** @type {unknown} */terserMinify),
+      minimizerOptions,
+      terserOptions,
+      test = /\.[cm]?js(\?.*)?$/i,
+      extractComments = true,
+      parallel = true,
+      include,
+      exclude
+    } = options || {};
+
+    // `terserOptions` is a deprecated alias of `minimizerOptions`; prefer the
+    // new name when both are provided.
+    const resolvedMinimizerOptions = /** @type {MinimizerOptions<T>} */
+
+    typeof minimizerOptions !== "undefined" ? minimizerOptions : terserOptions || {};
+
+    /**
+     * @private
+     * @type {InternalPluginOptions<T>}
+     */
+    this.options = {
+      test,
+      extractComments,
+      parallel,
+      include,
+      exclude,
+      minimizer: {
+        implementation: minify,
+        options: resolvedMinimizerOptions
+      }
+    };
+  }
+
+  /**
+   * @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;
+
+    // Normalize the implementation list to an array so dispatch and the
+    // worker-pool capability checks below can iterate uniformly. The
+    // original shape on `this.options.minimizer.implementation` is preserved
+    // for chunk hashing.
+    const implementations = Array.isArray(this.options.minimizer.implementation) ? this.options.minimizer.implementation : [this.options.minimizer.implementation];
+
+    /**
+     * Collect the indices of minimizers whose `filter` accepts `name`.
+     * Filters returning `undefined` are treated as accept (matches the
+     * convention used by `supportsWorkerThreads`).
+     * @param {string} name asset name
+     * @param {AssetInfo} info asset info
+     * @returns {number[]} indices into `implementations` that accept the asset
+     */
+    const matchingMinimizers = (name, info) => {
+      const matched = [];
+      for (let i = 0; i < implementations.length; i++) {
+        const impl = implementations[i];
+        if (typeof impl.filter !== "function" ||
+        // eslint-disable-next-line unicorn/no-array-method-this-argument
+        impl.filter(name, info) !== false) {
+          matched.push(i);
+        }
+      }
+      return matched;
+    };
+    /** @type {Map<string, number[]>} */
+    const matchedByName = new Map();
+    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;
+      }
+
+      // Compute the matching minimizers once and carry the result to the
+      // per-asset task via `matchedByName` so the regexes don't run again.
+      const matched = matchingMinimizers(name, info);
+      if (matched.length === 0) {
+        return false;
+      }
+      matchedByName.set(name, matched);
+      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,
+        matched: (/** @type {number[]} */matchedByName.get(name))
+      };
+    }));
+    if (assetsForMinify.length === 0) {
+      return;
+    }
+
+    /** @type {undefined | (() => MinimizerWorker<T>)} */
+    let getWorker;
+    /** @type {undefined | MinimizerWorker<T>} */
+    let initializedWorker;
+    /** @type {undefined | number} */
+    let numberOfWorkers;
+    const needCreateWorker = optimizeOptions.availableNumberOfCores > 0 && implementations.every(impl => typeof impl.supportsWorker === "undefined" || typeof impl.supportsWorker === "function" && impl.supportsWorker());
+    if (needCreateWorker) {
+      // 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: implementations.every(impl => typeof impl.supportsWorkerThreads === "undefined" || impl.supportsWorkerThreads() !== false)
+        });
+
+        // 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,
+          matched
+        } = 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();
+          }
+
+          // Dispatch to only the minimizers whose `filter` accepted this
+          // asset (computed once when collecting `assetsForMinify`).
+          // `minify.js` already normalizes a single implementation into a
+          // one-element array, so we always hand it the matching subset.
+          // Options are sliced as references — `minify.js` overlays
+          // `module`/`ecma` without mutating the caller's object.
+          const assetImplementation = /** @type {MinimizerImplementation<T>} */
+          matched.map(i => implementations[i]);
+          const sourceOptions = this.options.minimizer.options;
+          const assetMinimizerOptions = /** @type {MinimizerOptions<T>} */
+
+          Array.isArray(sourceOptions) ? matched.map(i => sourceOptions[i] || {}) : sourceOptions;
+
+          /**
+           * @type {InternalOptions<T>}
+           */
+          const options = {
+            name,
+            input,
+            inputSourceMap,
+            minimizer: {
+              implementation: assetImplementation,
+              options: assetMinimizerOptions
+            },
+            extractComments: this.options.extractComments
+          };
+          if (typeof info.javascriptModule !== "undefined") {
+            options.module = info.javascriptModule;
+          } else if (/\.mjs(\?.*)?$/i.test(name)) {
+            options.module = true;
+          } else if (/\.cjs(\?.*)?$/i.test(name)) {
+            options.module = false;
+          }
+          options.ecma = 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));
+          }
+          let shebang;
+
+          // Custom functions can return `undefined` or `null` when the
+          // minimizer only produced warnings, errors or extracted comments
+          if (typeof output.code !== "undefined" && output.code !== null) {
+            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);
+
+            // Banner only applies when we have a new source to prepend to
+            if (output.source && /** @type {ExtractCommentsObject} */
+            this.options.extractComments.banner !== false) {
+              let 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);
+          }
+        }
+
+        // Emit extracted comments file even if the main asset was not
+        // rewritten (some minimizers only produce comments / warnings / errors)
+        if (output.extractedCommentsSource) {
+          allExtractedComments.set(name, {
+            extractedCommentsSource: output.extractedCommentsSource,
+            commentsFilename: (/** @type {string} */output.commentsFilename)
+          });
+        }
+        if (!output.source) {
+          return;
+        }
+
+        /** @type {AssetInfo} */
+        const newInfo = {
+          minimized: true
+        };
+        if (output.extractedCommentsSource) {
+          newInfo.related = {
+            license: (/** @type {string} */output.commentsFilename)
+          };
+        }
+        compilation.updateAsset(name, output.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());
+  }
+
+  /**
+   * @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);
+      /**
+       * @param {BasicMinimizerImplementation<EXPECTED_ANY> & MinimizeFunctionHelpers} impl implementation
+       * @returns {string} minimizer version or "0.0.0"
+       */
+      const getVersion = impl => typeof impl.getMinimizerVersion !== "undefined" ? impl.getMinimizerVersion() || "0.0.0" : "0.0.0";
+      const data = getSerializeJavascript()({
+        minimizer: Array.isArray(this.options.minimizer.implementation) ? this.options.minimizer.implementation.map(getVersion) : getVersion(/** @type {BasicMinimizerImplementation<EXPECTED_ANY> & MinimizeFunctionHelpers} */
+        this.options.minimizer.implementation),
+        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("minimizer-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;
+TerserPlugin.jsonMinify = jsonMinify;
+TerserPlugin.htmlMinifierTerser = htmlMinifierTerser;
+TerserPlugin.swcMinifyHtml = swcMinifyHtml;
+TerserPlugin.swcMinifyHtmlFragment = swcMinifyHtmlFragment;
+TerserPlugin.minifyHtmlNode = minifyHtmlNode;
+TerserPlugin.cssnanoMinify = cssnanoMinify;
+TerserPlugin.cssoMinify = cssoMinify;
+TerserPlugin.cleanCssMinify = cleanCssMinify;
+TerserPlugin.esbuildMinifyCss = esbuildMinifyCss;
+TerserPlugin.lightningCssMinify = lightningCssMinify;
+TerserPlugin.swcMinifyCss = swcMinifyCss;
+module.exports = TerserPlugin;

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

@@ -0,0 +1,335 @@
+"use strict";
+
+/** @typedef {import("./index.js").MinimizedResult} MinimizedResult */
+/** @typedef {import("./index.js").CustomOptions} CustomOptions */
+/** @typedef {import("./index.js").RawSourceMap} RawSourceMap */
+/**
+ * @template T
+ * @typedef {import("./index.js").MinimizerOptions<T>} MinimizerOptions
+ */
+
+const VLQ_BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+/**
+ * Encode a single integer as Base64 VLQ as used by the source-map spec.
+ * @param {number} value integer to encode
+ * @returns {string} encoded VLQ characters
+ */
+/* eslint-disable prefer-destructuring, no-eq-null, eqeqeq */
+/**
+ * @param {number} value integer to encode
+ * @returns {string} encoded VLQ characters
+ */
+function encodeVlq(value) {
+  let vlq = value < 0 ? -value << 1 | 1 : value << 1;
+  let out = "";
+  do {
+    let digit = vlq & 0b11111;
+    vlq >>>= 5;
+    if (vlq > 0) {
+      digit |= 0b100000;
+    }
+    out += VLQ_BASE64[digit];
+  } while (vlq > 0);
+  return out;
+}
+
+/**
+ * Encode decoded source-map mappings (per-line arrays of segments) back into
+ * the spec's `mappings` string.
+ * @param {number[][][]} decoded mappings as nested arrays of segments
+ * @returns {string} encoded `mappings` field
+ */
+function encodeMappings(decoded) {
+  let result = "";
+  let prevSourceIdx = 0;
+  let prevOriginalLine = 0;
+  let prevOriginalColumn = 0;
+  let prevNameIdx = 0;
+  for (let line = 0; line < decoded.length; line++) {
+    if (line > 0) {
+      result += ";";
+    }
+    let prevGeneratedColumn = 0;
+    const segments = decoded[line];
+    for (let i = 0; i < segments.length; i++) {
+      if (i > 0) {
+        result += ",";
+      }
+      const seg = segments[i];
+      result += encodeVlq(seg[0] - prevGeneratedColumn);
+      prevGeneratedColumn = seg[0];
+      if (seg.length >= 4) {
+        result += encodeVlq(seg[1] - prevSourceIdx);
+        prevSourceIdx = seg[1];
+        result += encodeVlq(seg[2] - prevOriginalLine);
+        prevOriginalLine = seg[2];
+        result += encodeVlq(seg[3] - prevOriginalColumn);
+        prevOriginalColumn = seg[3];
+        if (seg.length >= 5) {
+          result += encodeVlq(seg[4] - prevNameIdx);
+          prevNameIdx = seg[4];
+        }
+      }
+    }
+  }
+  return result;
+}
+
+/**
+ * Compose a freshly-produced source map with the input source map fed to
+ * the minimizer. `currentMap` represents `name → step-output` and
+ * `prevMap` represents `original → name`; the result represents
+ * `original → step-output`.
+ *
+ * TODO: replace with a webpack-sources helper once one is exposed —
+ * `SourceMapSource` already composes one level via `innerSourceMap`,
+ * see https://github.com/webpack/webpack-sources for the proposal to
+ * expose it as a public `composeSourceMaps` (or n-step `SourceMapSource`).
+ * @param {RawSourceMap | undefined} currentMap map produced by the minimizer
+ * @param {RawSourceMap | undefined} prevMap input source map fed to the minimizer
+ * @param {string} name name of the asset that the current map points to
+ * @returns {RawSourceMap | undefined} composed map
+ */
+function composeSourceMaps(currentMap, prevMap, name) {
+  if (!currentMap || !prevMap) {
+    return currentMap;
+  }
+
+  // Custom minimizers may return the map as a JSON string (e.g. terser's
+  // default output). `TraceMap` accepts both shapes, but we still hand
+  // back the original `currentMap` (string preserved) when the previous
+  // map can't be combined.
+  const {
+    TraceMap,
+    decodedMappings,
+    originalPositionFor,
+    sourceContentFor
+  } = require("@jridgewell/trace-mapping");
+  const current = new TraceMap(/** @type {import("@jridgewell/trace-mapping").SourceMapInput} */
+  /** @type {unknown} */currentMap);
+  const previous = new TraceMap(/** @type {import("@jridgewell/trace-mapping").SourceMapInput} */
+  /** @type {unknown} */prevMap);
+
+  /** @type {string[]} */
+  const sources = [];
+  /** @type {(string | null)[]} */
+  const sourcesContent = [];
+  /** @type {string[]} */
+  const names = [];
+  /** @type {Map<string, number>} */
+  const sourceIdx = new Map();
+  /** @type {Map<string, number>} */
+  const nameIdx = new Map();
+
+  /**
+   * @param {string | null | undefined} source source identifier
+   * @param {string | undefined} content source content (when available)
+   * @returns {number} index assigned in the composed map
+   */
+  const getSourceIdx = (source, content) => {
+    const key = source || "";
+    let idx = sourceIdx.get(key);
+    if (typeof idx === "undefined") {
+      idx = sources.length;
+      sources.push(key);
+      sourcesContent.push(typeof content === "string" ? content : null);
+      sourceIdx.set(key, idx);
+    } else if (typeof content === "string" && sourcesContent[idx] === null) {
+      sourcesContent[idx] = content;
+    }
+    return idx;
+  };
+
+  /**
+   * @param {string | null | undefined} value name
+   * @returns {number} index assigned in the composed map
+   */
+  const getNameIdx = value => {
+    if (typeof value !== "string") {
+      return -1;
+    }
+    let idx = nameIdx.get(value);
+    if (typeof idx === "undefined") {
+      idx = names.length;
+      names.push(value);
+      nameIdx.set(value, idx);
+    }
+    return idx;
+  };
+  const decoded = decodedMappings(current);
+  const currentSources = current.sources.map(
+  /**
+   * @param {string | null} source source from current map
+   * @returns {string} normalized source string
+   */
+  source => source || "");
+  const currentNames = current.names;
+
+  /** @type {number[][][]} */
+  const composed = [];
+  for (let line = 0; line < decoded.length; line++) {
+    /** @type {number[][]} */
+    const newSegments = [];
+    for (const rawSeg of decoded[line]) {
+      const seg = /** @type {number[]} */rawSeg;
+
+      // Single-element segment is just a generated column with no source info
+      if (seg.length < 4) {
+        newSegments.push([seg[0]]);
+        continue;
+      }
+      const sourceName = currentSources[seg[1]];
+      const origLine = /** @type {number} */seg[2];
+      const origCol = /** @type {number} */seg[3];
+      const segName = seg.length >= 5 ? currentNames[seg[4]] : (/** @type {string | null} */null);
+
+      // When the segment points back at our intermediate `name`, look up
+      // the original position in the previous map and emit a mapping that
+      // points all the way back. Otherwise keep the segment as-is.
+      if (sourceName === name) {
+        const orig = originalPositionFor(previous, {
+          line: origLine + 1,
+          column: origCol
+        });
+        if (typeof orig.source !== "string" || orig.line == null || orig.column == null) {
+          continue;
+        }
+        const content = sourceContentFor(previous, orig.source) || undefined;
+        const newSrcIdx = getSourceIdx(orig.source, content);
+        const finalName = typeof orig.name === "string" && orig.name ? orig.name : segName;
+        if (typeof finalName === "string") {
+          newSegments.push([seg[0], newSrcIdx, orig.line - 1, orig.column, getNameIdx(finalName)]);
+        } else {
+          newSegments.push([seg[0], newSrcIdx, orig.line - 1, orig.column]);
+        }
+      } else {
+        const content = sourceContentFor(current, sourceName) || undefined;
+        const newSrcIdx = getSourceIdx(sourceName, content);
+        if (typeof segName === "string") {
+          newSegments.push([seg[0], newSrcIdx, origLine, origCol, getNameIdx(segName)]);
+        } else {
+          newSegments.push([seg[0], newSrcIdx, origLine, origCol]);
+        }
+      }
+    }
+    composed.push(newSegments);
+  }
+  const result = /** @type {RawSourceMap} */
+
+  /** @type {unknown} */{
+    version: 3,
+    sources,
+    names,
+    mappings: encodeMappings(composed)
+  };
+  if (currentMap.file) {
+    result.file = currentMap.file;
+  }
+  if (sourcesContent.some(value => typeof value === "string")) {
+    result.sourcesContent = /** @type {string[]} */
+    /** @type {unknown} */sourcesContent;
+  }
+  return result;
+}
+/* eslint-enable prefer-destructuring, no-eq-null, eqeqeq */
+
+/**
+ * @template T
+ * @param {import("./index.js").InternalOptions<T>} options options
+ * @returns {Promise<MinimizedResult>} minified result
+ */
+async function minify(options) {
+  const {
+    name,
+    input,
+    inputSourceMap,
+    extractComments,
+    module,
+    ecma
+  } = options;
+  const {
+    implementation,
+    options: minimizerOptions
+  } = options.minimizer;
+  const implementations = Array.isArray(implementation) ? implementation : [implementation];
+
+  /** @type {string | undefined} */
+  let lastCode;
+  /** @type {RawSourceMap | undefined} */
+  let lastMap;
+  /** @type {(Error | string)[]} */
+  const warnings = [];
+  /** @type {(Error | string)[]} */
+  const errors = [];
+  /** @type {string[]} */
+  const extractedComments = [];
+  for (let i = 0; i < implementations.length; i++) {
+    const currentImplementation = /** @type {import("./index.js").BasicMinimizerImplementation<T> & import("./index.js").MinimizeFunctionHelpers} */
+    implementations[i];
+    const baseOptions = /** @type {import("./index.js").MinimizerOptions<T> & { module?: boolean, ecma?: number | string }} */
+
+    Array.isArray(minimizerOptions) ? minimizerOptions[i] || {} : minimizerOptions || {};
+    const currentInput = typeof lastCode === "string" ? lastCode : input;
+    const currentMap = typeof lastCode === "string" ? lastMap : inputSourceMap;
+
+    // Overlay `module` and `ecma` without mutating the caller's options so
+    // a single options object can be reused safely across assets.
+    const currentOptions = /** @type {import("./index.js").MinimizerOptions<T>} */
+    {
+      ...baseOptions,
+      module: baseOptions.module || module,
+      ecma: baseOptions.ecma || ecma
+    };
+    const result = await currentImplementation({
+      [name]: currentInput
+    }, currentMap, currentOptions, extractComments);
+    if (result.warnings && result.warnings.length > 0) {
+      warnings.push(...result.warnings);
+    }
+    if (result.errors && result.errors.length > 0) {
+      errors.push(...result.errors);
+    }
+    if (result.extractedComments && result.extractedComments.length > 0) {
+      extractedComments.push(...result.extractedComments);
+    }
+    if (typeof result.code === "string") {
+      lastCode = result.code;
+      // The minimizer's output map is `name → step-output`. Chain it with
+      // the previous accumulated map so that across an array of minimizers
+      // the final map points back to the original sources.
+      lastMap = composeSourceMaps(result.map, currentMap, name);
+    }
+  }
+  return {
+    code: lastCode,
+    map: lastMap,
+    warnings,
+    errors,
+    extractedComments
+  };
+}
+
+/**
+ * @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,205 @@
+{
+  "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": "MinimizerPluginOptions",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "test": {
+      "description": "Include all modules that pass test assertion.",
+      "link": "https://github.com/webpack/minimizer-webpack-plugin#test",
+      "oneOf": [
+        {
+          "$ref": "#/definitions/Rules"
+        }
+      ]
+    },
+    "include": {
+      "description": "Include all modules matching any of these conditions.",
+      "link": "https://github.com/webpack/minimizer-webpack-plugin#include",
+      "oneOf": [
+        {
+          "$ref": "#/definitions/Rules"
+        }
+      ]
+    },
+    "exclude": {
+      "description": "Exclude all modules matching any of these conditions.",
+      "link": "https://github.com/webpack/minimizer-webpack-plugin#exclude",
+      "oneOf": [
+        {
+          "$ref": "#/definitions/Rules"
+        }
+      ]
+    },
+    "minimizerOptions": {
+      "description": "Options for `terser` (by default) or custom `minify` function.",
+      "link": "https://github.com/webpack/minimizer-webpack-plugin#minimizeroptions",
+      "anyOf": [
+        {
+          "additionalProperties": true,
+          "type": "object"
+        },
+        {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "additionalProperties": true,
+            "type": "object"
+          }
+        }
+      ]
+    },
+    "terserOptions": {
+      "description": "Deprecated alias for `minimizerOptions`. Options for `terser` (by default) or custom `minify` function.",
+      "link": "https://github.com/webpack/minimizer-webpack-plugin#terseroptions",
+      "anyOf": [
+        {
+          "additionalProperties": true,
+          "type": "object"
+        },
+        {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "additionalProperties": true,
+            "type": "object"
+          }
+        }
+      ]
+    },
+    "extractComments": {
+      "description": "Whether comments shall be extracted to a separate file.",
+      "link": "https://github.com/webpack/minimizer-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/minimizer-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/minimizer-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/minimizer-webpack-plugin#banner"
+            }
+          },
+          "type": "object"
+        }
+      ]
+    },
+    "parallel": {
+      "description": "Use multi-process parallel running to improve the build speed.",
+      "link": "https://github.com/webpack/minimizer-webpack-plugin#parallel",
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "integer"
+        }
+      ]
+    },
+    "minify": {
+      "description": "Allows you to override default minify function.",
+      "link": "https://github.com/webpack/minimizer-webpack-plugin#number",
+      "anyOf": [
+        {
+          "instanceof": "Function"
+        },
+        {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "instanceof": "Function"
+          }
+        }
+      ]
+    }
+  }
+}

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

@@ -0,0 +1,276 @@
+"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 (Array.isArray(origValue)) {
+        var isSparse = Object.keys(origValue).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);
+  });
+};