index.js

const crypto = require("crypto");
const os = require("os");
const path = require("path");

const { minify } = require("./minify");
const {
  cleanCssMinify,
  compress,
  cssnanoMinify,
  cssoMinify,
  esbuildMinify,
  esbuildMinifyCss,
  getEcmaVersion,
  getMinimizerOptionsAt,
  htmlMinifierTerser,
  imageminGenerate,
  imageminMinify,
  imageminNormalizeConfig,
  interpolateSize,
  isDescriptor,
  isPresets,
  jsonMinify,
  lightningCssMinify,
  memoize,
  minifyHtmlNode,
  napiRsImageMinify,
  normalizeMinimizers,
  readPreset,
  sharpGenerate,
  sharpMinify,
  svgoMinify,
  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
 */

/**
 * What one embedded source is and where it is going, as
 * `renderEmbeddedSource` describes it.
 * @typedef {object} EmbeddedSourceInfo
 * @property {string} type the embedded source's language, e.g. `"css"`
 * @property {string} hostType the language of the output it is embedded in
 * @property {import("webpack").Module} module the module being generated
 */

/**
 * The two hooks webpack >= 5.110 adds. Declared here rather than read off
 * `Compilation`: the plugin supports webpack `^5.1.0`, whose types have
 * neither, and it does nothing at all where they are absent.
 * @typedef {object} EmbeddedSourceHooks
 * @property {{ tapPromise: (name: string, fn: (source: import("webpack").sources.Source, info: EmbeddedSourceInfo) => Promise<import("webpack").sources.Source>) => void }=} renderEmbeddedSource offers each embedded source before it is embedded
 * @property {{ tap: (name: string, fn: (module: import("webpack").Module, hash: { update: (data: string) => void }) => void) => void }=} embeddedSourceHash hashes what a `renderEmbeddedSource` tap varies on
 */

/**
 * What the loaders produced for one module, as `processResult` hands it over.
 * @typedef {[string | Buffer, string | RawSourceMap | undefined, EXPECTED_ANY]} LoaderResult
 */

/**
 * The `NormalModule` hook this plugin generates through. Declared here for the
 * same reason as `EmbeddedSourceHooks`: it can await only from webpack 5.111,
 * and the supported range's types still describe it as synchronous.
 * @typedef {object} AwaitableModuleHooks
 * @property {{ tapPromise: (name: string, fn: (result: LoaderResult, module: import("webpack").NormalModule) => Promise<LoaderResult>) => void }} processResult offers each module's own bytes as it is built
 */

/**
 * @typedef {object} MinimizedResult
 * @property {(string | Buffer)=} code code — a `Buffer` from a minimizer that declares `supportsBinary`
 * @property {string=} filename the name the result should carry, when re-encoding it changed what the bytes are. Only the `generate` path can honour it: an asset is named while its module is built, before anything downstream refers to it
 * @property {number=} width what the result is now wide, where re-encoding knows it. `[width]` in an `asset` generator's `filename` reads it
 * @property {number=} height what the result is now tall, where re-encoding knows it
 * @property {RawSourceMap=} map source map
 * @property {(Error | string)[]=} errors errors
 * @property {(Error | string)[]=} warnings warnings
 * @property {string[]=} extractedComments extracted comments
 */

/**
 * @typedef {{ [file: string]: string | Buffer }} 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 {() => boolean | undefined=} supportsBinary true when the minimizer takes the asset's bytes rather than its text — an image minimizer. Its input reaches it as a `Buffer` and its `code` may be one. Only when every minimizer an asset is dispatched to declares it, since one that does not could not read the bytes
 * @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.
 * @property {() => string[] | undefined=} getTypes the languages this minimizer minifies, e.g. `["css"]`. Source that carries no filename — what a module embeds in another language's output — is dispatched by this rather than by `test` / `filter`, and a minimizer that declares nothing is never handed any
 * @property {(minimizerOptions?: EXPECTED_OBJECT) => string[] | undefined=} getEmbeddedTypes the languages this minimizer can hand out from inside what it minifies, through the `renderEmbeddedSource` option. Empty (or absent) means it nests nothing a caller can reach, and the option is not passed
 * @property {(compilation: typeof import("webpack").Compilation) => number | undefined=} getStage which `processAssets` stage this minimizer has to run in, named off the `Compilation` it is handed — compressing reads the bytes a user downloads, so it asks for `PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER`. Each runs where it asks, chaining through the asset a later pass reads back, and one asking for nothing runs where minifying belongs — after the bundle is rendered and before its hashes are taken
 * @property {() => string | undefined=} getAssetFlag the name this function's work goes under in the asset's info, which is what the asset it wrote is marked with and what stats print. `compress` says `compressed`, another encoding of the bytes being no smaller a version of them; a minimizer saying nothing minified the asset, so `minimized`, and a generator saying nothing wrote a new file, so `generated`. It is also what is not run twice: an asset already marked with every name a function writes is declined, which is how a minified asset a child compilation handed up is left alone
 */

/**
 * @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 | Buffer} input input — bytes for a minimizer that declares `supportsBinary`
 * @property {RawSourceMap | undefined} inputSourceMap input source map
 * @property {ExtractCommentsOptions | undefined} extractComments extract comments option
 * @property {{ implementation: MinimizerImplementation<T>, options: MinimizerOptions<T> }} minimizer minimizer
 * @property {{ implementation: MinimizerImplementation<T>, options: MinimizerOptions<T>, claims: string[][], offers: string[][], at: number[] }=} embedded every configured minimizer, for source one language embeds in another: it carries no filename, so `minimizer` — which holds only what this asset's name matched — is not the set to dispatch it across. `claims` is the languages each minifies and `offers` the languages each can hand out, both as data and both parallel to `implementation`, since a minify function reaches a worker as source and carries none of its properties; `at` says which of them `minimizer` holds. Absent when no nested language is reachable at all
 * @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
 */

/**
 * One generator, written as an object stating how to run it.
 * @typedef {object} GeneratorDescriptor
 * @property {MinimizerImplementation<EXPECTED_ANY>} implementation the generator itself
 * @property {MinimizerOptions<EXPECTED_ANY>=} options options for this generator, preferred over the deprecated `generatorOptions`
 * @property {("import" | "asset")=} type `import` re-encodes a module as it is built, so the import that asked for it is renamed with it; `asset` writes a new file beside one already emitted
 * @property {string=} filename name for the generated asset, as a webpack filename template. `asset` generators only
 * @property {((name: string) => boolean)=} filter decides per asset whether to generate from it, on top of `test`/`include`/`exclude`
 * @property {boolean=} deleteOriginalAssets removes the asset generated from. `asset` generators only
 * @property {number=} threshold generate only from assets larger than this, in bytes. `asset` generators only
 * @property {number=} minRatio keep the generated asset only when it is this much smaller than the one it was read from. `asset` generators only
 * @property {(string | false)=} relatedName the key the generated asset is recorded under in the original's `related` info. `asset` generators only
 */

/**
 * What `generate` may be written as: one generator, a list of them, a
 * descriptor, or an object naming descriptors an asset asks for with `?as=`.
 * @typedef {MinimizerImplementation<EXPECTED_ANY> | MinimizerImplementation<EXPECTED_ANY>[] | GeneratorDescriptor | { [preset: string]: MinimizerImplementation<EXPECTED_ANY> | MinimizerImplementation<EXPECTED_ANY>[] | GeneratorDescriptor }} Generate
 */

/**
 * @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
 * @property {Generate=} generate rewrites a module's own bytes as it is built, so a re-encoding can rename the asset, or writes a new file beside one already emitted
 * @property {MinimizerOptions<EXPECTED_ANY>=} generatorOptions options for `generate`
 */

/**
 * @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>, filters?: (((name: string, info: AssetInfo) => boolean | undefined) | undefined)[] }, generator?: { implementation: MinimizerImplementation<T>, options: MinimizerOptions<T> } }} InternalPluginOptions
 */

/**
 * The `processAssets` stage a minimizer or generator asks for, which is the
 * latest of them where several run as one chain.
 * @param {Compiler} compiler compiler
 * @param {EXPECTED_ANY} implementation one implementation, or an array of them
 * @returns {number | undefined} the stage, or undefined where none asks
 */
const declaredStage = (compiler, implementation) => {
  const each = Array.isArray(implementation)
    ? implementation
    : [implementation];
  let latest;

  for (const one of each) {
    const asked =
      one && typeof one.getStage === "function"
        ? one.getStage(compiler.webpack.Compilation)
        : undefined;

    if (
      typeof asked === "number" &&
      (typeof latest !== "number" || asked > latest)
    ) {
      latest = asked;
    }
  }

  return latest;
};

/**
 * The name a chunk's JavaScript asset will take, as far as it is knowable
 * while the hash that name contains is still being computed.
 * @param {Compilation} compilation compilation
 * @param {import("webpack").Chunk} chunk chunk
 * @returns {string | undefined} the name, or undefined where a function names it
 */
const chunkAssetName = (compilation, chunk) => {
  const { outputOptions } = compilation;
  const template =
    chunk.filenameTemplate ||
    (chunk.canBeInitial()
      ? outputOptions.filename
      : outputOptions.chunkFilename);

  if (typeof template !== "string") {
    return undefined;
  }

  // Every placeholder stands for text it has not got yet: what is being asked
  // of the name is its path and extension, which none of them carries.
  return template
    .replace(/\[(?:full|chunk|content)hash(?::\d+)?]/gi, "0")
    .replace(/\[name]/gi, String(chunk.name || chunk.id))
    .replace(/\[id]/gi, String(chunk.id))
    .replace(/\[runtime]/gi, String(chunk.runtime));
};

/**
 * The names an implementation's work goes under in an asset's info, which is
 * the union where several ran as one chain.
 * @param {EXPECTED_ANY} implementation one implementation, or an array of them
 * @param {string} fallback the name to use where none says
 * @returns {string[]} the names
 */
const declaredFlags = (implementation, fallback) => {
  const each = Array.isArray(implementation)
    ? implementation
    : [implementation];
  /** @type {string[]} */
  const names = [];

  for (const one of each) {
    const says =
      one && typeof one.getAssetFlag === "function"
        ? one.getAssetFlag()
        : undefined;

    if (typeof says === "string" && says && !names.includes(says)) {
      names.push(says);
    }
  }

  return names.length > 0 ? names : [fallback];
};

/**
 * Whether an asset is already marked with every name a function writes,
 * counting only what this plugin did not mark it with itself.
 * @param {Record<string, EXPECTED_ANY>} says what the asset says about itself
 * @param {Set<string> | undefined} written what this plugin marked it with
 * @param {string[]} flags the names the function writes
 * @returns {boolean} true when it has been through this already
 */
const saysAlready = (says, written, flags) => {
  for (const flag of flags) {
    if (!says[flag] || (written && written.has(flag))) {
      return false;
    }
  }

  return true;
};

const VALIDATION_CONFIGURATION = {
  name: "Minimizer Plugin",
  baseDataPath: "options",
};

const getTraceMapping = memoize(() => require("@jridgewell/trace-mapping"));
const getSerializeJavascript = memoize(() => require("./serialize-javascript"));

/**
 * @template [T=import("terser").MinifyOptions]
 */
class MinimizerPlugin {
  /**
   * @param {BasePluginOptions & DefinedDefaultMinimizerAndOptions<T>=} options options
   */
  constructor(options) {
    // Kept for `apply()`, which is where validation runs now: webpack owns when
    // it happens, and skips it entirely for `validate: false`.
    /**
     * @private
     * @type {BasePluginOptions & DefinedDefaultMinimizerAndOptions<T>}
     */
    this.rawOptions =
      /** @type {BasePluginOptions & DefinedDefaultMinimizerAndOptions<T>} */
      (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: declaredMinify,
      minimizerOptions,
      terserOptions,
      test: declaredTest,
      extractComments = true,
      parallel = true,
      include,
      exclude,
      generate,
      generatorOptions,
    } = this.rawOptions;

    // The JavaScript minifier and the names it reads are what this plugin is,
    // so both stand whether or not a generator was configured too.
    const minimizers =
      typeof declaredMinify !== "undefined"
        ? declaredMinify
        : /** @type {MinimizerImplementation<T>} */ (
            /** @type {unknown} */ (terserMinify)
          );
    const test =
      typeof declaredTest !== "undefined" ? declaredTest : /\.[cm]?js(\?.*)?$/i;

    // `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:
        /** @type {{ implementation: MinimizerImplementation<T>, options: MinimizerOptions<T>, filters?: (((name: string, info: AssetInfo) => boolean | undefined) | undefined)[] }} */
        (normalizeMinimizers(minimizers, resolvedMinimizerOptions)),
      // Absent unless asked for: it runs while modules build, where the plugin
      // otherwise does nothing.
      generator: generate
        ? {
            implementation:
              /** @type {MinimizerImplementation<T>} */
              (/** @type {unknown} */ (generate)),
            options:
              /** @type {MinimizerOptions<T>} */
              (/** @type {unknown} */ (generatorOptions || {})),
          }
        : undefined,
    };
  }

  /**
   * @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 minimizer-webpack-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 minimizer-webpack-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 minimizer-webpack-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 minimizer-webpack-plugin\n${
          typeof error.message !== "undefined" ? error.message : ""
        }\n${error.stack}`,
      );
      builtError.file = file;

      return builtError;
    }

    builtError = new Error(
      `${file} from minimizer-webpack-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);
  }

  /**
   * Whether `test`, `include` and `exclude` accept a name.
   *
   * An asset name carries the query and fragment of the request that made it
   * — `output.assetModuleFilename` is `[hash][ext][query][fragment]` by
   * default — so `test: /\.png$/` would match none of them. Both spellings
   * are offered: a rule naming the file accepts it whatever it carries, and
   * one naming the query still works.
   * @private
   * @param {Compiler} compiler compiler
   * @param {string} name asset name, or a module's resource
   * @returns {boolean} true when it is to be minified
   */
  matchesName(compiler, name) {
    const { matchPart } = compiler.webpack.ModuleFilenameHelpers;
    const bare = name.replace(/[?#].*$/, "");
    const { test, include, exclude } = this.options;

    if (test && !matchPart(name, test) && !matchPart(bare, test)) {
      return false;
    }

    if (include && !matchPart(name, include) && !matchPart(bare, include)) {
      return false;
    }

    // Rejecting on either spelling, so naming the file excludes it whatever
    // it carries and naming the query still excludes it.
    return !(exclude && (matchPart(name, exclude) || matchPart(bare, exclude)));
  }

  /**
   * @private
   * @param {Compiler} compiler compiler
   * @param {Compilation} compilation compilation
   * @param {Record<string, import("webpack").sources.Source>} assets assets
   * @param {{ availableNumberOfCores: number, only?: number[], cacheSuffix?: string, written: Map<string, Set<string>> }} optimizeOptions how many may run at once, which minimizers this pass runs, what keeps its cache apart from another pass over the same asset, and what an earlier pass of this plugin already wrote onto each asset
   * @returns {Promise<void>}
   */
  async optimize(compiler, compilation, assets, optimizeOptions) {
    // The namespace is the name this plugin shipped under, and renaming it
    // would throw away every warm pack for nothing a user can see.
    const cache = compilation.getCache("TerserWebpackPlugin");
    let numberOfAssets = 0;

    /**
     * @param {string} name asset name
     * @returns {boolean} true when the asset is to be minified
     */
    const matchesName = (name) => this.matchesName(compiler, name);

    // 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];

    // What each minimizer marks an asset with, asked once here rather than
    // again for every asset it is offered.
    const flagsByMinimizer = implementations.map((one) =>
      declaredFlags(one, "minimized"),
    );

    // `additionalAssets` hands this pass whatever was emitted after it ran,
    // this plugin's own generated files included, and those are not to minify.
    const generated = this.generatedFlags();

    /**
     * Remember what this plugin marked an asset with, which is what a later
     * pass of it reads back rather than declining.
     * @param {string} name asset name
     * @param {string[]} flags the names written
     * @returns {void}
     */
    const recordWritten = (name, flags) => {
      let written = optimizeOptions.written.get(name);

      if (!written) {
        written = new Set();
        optimizeOptions.written.set(name, written);
      }

      for (const flag of flags) {
        written.add(flag);
      }
    };

    /**
     * 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 = [];
      const { filters } = this.options.minimizer;
      const written = optimizeOptions.written.get(name);
      const says = /** @type {Record<string, EXPECTED_ANY>} */ (info);

      for (let i = 0; i < implementations.length; i++) {
        // A pass runs only the minimizers asking for its stage; the rest read
        // this same asset at theirs.
        if (optimizeOptions.only && !optimizeOptions.only.includes(i)) {
          continue;
        }

        const impl = implementations[i];

        // Skip double minimize assets from child compilation: one already
        // saying what this minimizer writes has been through it. An earlier
        // pass of this plugin is not that — those chain through the asset.
        if (saysAlready(says, written, flagsByMinimizer[i])) {
          continue;
        }

        // What `minify` states about this entry answers for it; the property on
        // the function is what a minimizer says about itself, and is the
        // fallback rather than a second filter to satisfy.
        const filter =
          filters && typeof filters[i] === "function"
            ? filters[i]
            : impl.filter;

        if (typeof filter !== "function" || 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));

          // Skip minimizing for extracted comments assets
          if (info.extractedComments) {
            return false;
          }

          const says = /** @type {Record<string, EXPECTED_ANY>} */ (info);

          if (generated.some((flag) => says[flag])) {
            return false;
          }

          if (!matchesName(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}${optimizeOptions.cacheSuffix || ""}`,
            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;

    // Per implementation rather than over all of them: an asset is dispatched
    // only to the minimizers its name matched, so one that cannot run in a
    // worker — an image minimizer, whose bytes have no way across — must not
    // take the pool away from the JavaScript ones configured beside it.
    const workerCapable = implementations.map(
      (impl) =>
        typeof impl.supportsWorker === "undefined" ||
        (typeof impl.supportsWorker === "function" && impl.supportsWorker()),
    );
    const binaryCapable = implementations.map(
      (impl) =>
        typeof impl.supportsBinary === "function" && impl.supportsBinary(),
    );
    const needCreateWorker =
      optimizeOptions.availableNumberOfCores > 0 &&
      workerCapable.includes(true);

    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,
              // Only what can reach the pool decides how it is run.
              enableWorkerThreads: implementations.every(
                (impl, i) =>
                  !workerCapable[i] ||
                  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;

    /**
     * @param {InternalOptions<T>} options what to minify
     * @param {number[]} matched indices of the minimizers this asset is dispatched to
     * @returns {Promise<MinimizedResult>} the result
     */
    const run = (options, matched) =>
      getWorker && matched.every((i) => workerCapable[i])
        ? getWorker().transform(getSerializeJavascript()(options))
        : minify(options);

    /** @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 (!MinimizerPlugin.isSourceMap(map)) {
              compilation.warnings.push(
                new Error(`${name} contains invalid source map`),
              );
            } else {
              inputSourceMap = /** @type {RawSourceMap} */ (map);
            }
          }

          // Only a minimizer that says it reads bytes gets them: every other
          // one is handed the text it has always been handed.
          if (
            Buffer.isBuffer(input) &&
            !matched.every((i) => binaryCapable[i])
          ) {
            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,
            embedded: this.embeddedMinimizer(matched),
          };

          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 run(options, matched);
          } catch (error) {
            const hasSourceMap =
              inputSourceMap && MinimizerPlugin.isSourceMap(inputSourceMap);

            compilation.errors.push(
              MinimizerPlugin.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 minimizer-webpack-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) => MinimizerPlugin.buildWarning(item, name),
            );
          }

          if (output.errors && output.errors.length > 0) {
            const hasSourceMap =
              inputSourceMap && MinimizerPlugin.isSourceMap(inputSourceMap);

            output.errors = output.errors.map(
              /**
               * @param {Error | string} item an error
               * @returns {Error} built error with extra info
               */
              (item) =>
                MinimizerPlugin.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 &&
              typeof output.code === "string" &&
              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 = {};

        // The name each minimizer this asset went through works under: a
        // minified asset, or another encoding of the same bytes.
        for (const at of matched) {
          for (const flag of flagsByMinimizer[at]) {
            /** @type {Record<string, EXPECTED_ANY>} */ (newInfo)[flag] = true;
          }
        }

        recordWritten(name, Object.keys(newInfo));

        if (output.extractedCommentsSource) {
          newInfo.related = {
            license: /** @type {string} */ (output.commentsFilename),
          };
        }

        compilation.updateAsset(name, output.source, newInfo);
      });
    }

    // Without the pool the work runs here, so the same bound applies: a
    // minimizer that holds a whole image in memory is not one to start once
    // per asset at the same moment.
    const limit =
      getWorker && numberOfAssets > 0
        ? /** @type {number} */ (numberOfWorkers)
        : optimizeOptions.availableNumberOfCores > 0
          ? Math.min(
              scheduledTasks.length,
              optimizeOptions.availableNumberOfCores,
            )
          : scheduledTasks.length;
    try {
      await throttleAll(limit, scheduledTasks);
    } finally {
      // A task that rejects after the pool started must not leave its
      // workers running — the process would never exit.
      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]) => {
        let previous =
          /** @type {ExtractedCommentsInfoWithFrom | undefined} * */ (
            await previousPromise
          );
        const { commentsFilename, extractedCommentsSource } = value;

        // Assets are visited in name order, so two that share a comments file
        // need not be adjacent; whatever already sits at the destination — an
        // earlier contributor, or a file another plugin emitted — is what this
        // one merges into.
        if (!previous || previous.commentsFilename !== commentsFilename) {
          const existingAsset = compilation.getAsset(commentsFilename);

          previous = existingAsset
            ? {
                source: existingAsset.source,
                commentsFilename,
                from: commentsFilename,
              }
            : undefined;
        }

        if (previous) {
          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) {
            const prevValue = prevSource.source();
            const extractedValue = extractedCommentsSource.source();

            source = new ConcatSource(
              [
                ...new Set([
                  ...(typeof prevValue === "string"
                    ? prevValue
                    : prevValue.toString("utf8")
                  ).split("\n\n"),
                  ...(typeof extractedValue === "string"
                    ? extractedValue
                    : extractedValue.toString("utf8")
                  ).split("\n\n"),
                ]),
              ].join("\n\n"),
            );

            await cache.storePromise(name, eTag, source);
          }

          compilation.updateAsset(commentsFilename, source);

          return { source, commentsFilename, from: mergedName };
        }

        compilation.emitAsset(commentsFilename, extractedCommentsSource, {
          extractedComments: true,
        });

        return { source: extractedCommentsSource, commentsFilename, from };
      },
      /** @type {Promise<unknown>} */ (Promise.resolve()),
    );
  }

  /**
   * Every configured minimizer, in order. The `minify` option takes one or an
   * array; embedded source is dispatched across all of them either way.
   * @private
   * @returns {(BasicMinimizerImplementation<EXPECTED_ANY> & MinimizeFunctionHelpers)[]} the minimizers
   */
  minimizers() {
    const { implementation } = this.options.minimizer;

    return /** @type {(BasicMinimizerImplementation<EXPECTED_ANY> & MinimizeFunctionHelpers)[]} */ (
      /** @type {unknown} */ (
        Array.isArray(implementation) ? implementation : [implementation]
      )
    );
  }

  /**
   * Every configured minimizer and its options, for dispatching source one
   * language embeds in another. The asset's own entry holds only what its
   * filename matched, and a language's minimizer need not be among them — a
   * `.css` asset embedding an `<svg>` reaches an SVG minifier that claims no
   * asset at all.
   * @private
   * @param {number[]} matched indices of the minimizers this input's own entry holds
   * @returns {{ implementation: MinimizerImplementation<T>, options: MinimizerOptions<T>, claims: string[][], offers: string[][], at: number[] } | undefined} every configured minimizer, or undefined when nothing nested could be reached
   */
  embeddedMinimizer(matched) {
    const minimizers = this.minimizers();
    // What each declares travels as data, not on the function: a minify function
    // reaches a worker as its source, which carries none of its properties.
    const claims = minimizers.map((minimizer) =>
      typeof minimizer.getTypes === "function"
        ? minimizer.getTypes() || []
        : [],
    );
    const offers = minimizers.map((minimizer, i) => {
      const { getEmbeddedTypes } = minimizer;

      return typeof getEmbeddedTypes === "function"
        ? getEmbeddedTypes(
            getMinimizerOptionsAt(this.options.minimizer.options, i),
          ) || []
        : [];
    });

    // Both declarations have to meet, or offering a body would only ever reach
    // one with nowhere to go.
    if (
      !matched.some((i) =>
        offers[i].some((type) =>
          claims.some((claimed) => claimed.includes(type)),
        ),
      )
    ) {
      return undefined;
    }

    return {
      implementation:
        /** @type {MinimizerImplementation<T>} */
        (/** @type {unknown} */ (minimizers)),
      options:
        /** @type {MinimizerOptions<T>} */
        (
          /** @type {unknown} */
          (
            minimizers.map((_, i) =>
              getMinimizerOptionsAt(this.options.minimizer.options, i),
            )
          )
        ),
      claims,
      offers,
      // Which of them this input's own entry holds, so the languages it can
      // offer are read off the same arrays after a round trip through a worker.
      at: matched,
    };
  }

  /**
   * One generator, however it was written: as the generator itself or as an
   * object stating how to run it.
   * @private
   * @param {string | undefined} name the preset it is written under, where it has one
   * @param {EXPECTED_ANY} entry what was written there
   * @param {EXPECTED_ANY} declared what `generatorOptions` says for it
   * @returns {{ name: string | undefined, implementation: EXPECTED_ANY, options: EXPECTED_ANY, type: string | undefined, filename: string | undefined, filter: ((name: string) => boolean) | undefined, deleteOriginalAssets: boolean | undefined, threshold: number | undefined, minRatio: number | undefined, relatedName: string | false | undefined }} the generator
   */
  describeGenerator(name, entry, declared) {
    const descriptor = isDescriptor(entry) ? entry : undefined;
    const own = descriptor ? descriptor.options : undefined;

    return {
      name,
      implementation: descriptor ? descriptor.implementation : entry,
      // TODO remove the `generatorOptions` fallback in the next major release,
      // where a generator's options are its own.
      options: (typeof own === "undefined" ? declared : own) || {},
      type: descriptor ? descriptor.type : undefined,
      filename: descriptor ? descriptor.filename : undefined,
      filter: descriptor ? descriptor.filter : undefined,
      deleteOriginalAssets: descriptor
        ? descriptor.deleteOriginalAssets
        : undefined,
      threshold: descriptor ? descriptor.threshold : undefined,
      minRatio: descriptor ? descriptor.minRatio : undefined,
      relatedName: descriptor ? descriptor.relatedName : undefined,
    };
  }

  /**
   * Every generator `generate` holds, whichever shape it was written in.
   * @private
   * @returns {ReturnType<MinimizerPlugin["describeGenerator"]>[]} them, in the order they were written
   */
  generators() {
    const { generator } = this.options;

    if (!generator) {
      return [];
    }

    const written = generator.implementation;
    const declared = generator.options;

    if (!isPresets(written) || isDescriptor(written)) {
      return [this.describeGenerator(undefined, written, declared)];
    }

    const presets =
      /** @type {{ [preset: string]: EXPECTED_ANY }} */
      (/** @type {unknown} */ (written));
    const perPreset =
      /** @type {{ [preset: string]: EXPECTED_ANY }} */
      (declared || {});

    return Object.keys(presets).map((preset) =>
      this.describeGenerator(preset, presets[preset], perPreset[preset]),
    );
  }

  /**
   * The generator a module asks for by name, or the only one there is.
   *
   * A `generate` naming its generators is picked between by `?as=`: a module
   * that names none is left alone, and one that names a generator nothing
   * defines is an error rather than a silent decline.
   * @private
   * @param {Compilation} compilation compilation
   * @param {string} resource the module's resource, query and all
   * @returns {{ implementation: MinimizerImplementation<EXPECTED_ANY>, options: MinimizerOptions<EXPECTED_ANY> } | undefined} the generator to run, or undefined to run none
   */
  generatorFor(compilation, resource) {
    const found = this.generators();
    const named = found.filter((one) => typeof one.name !== "undefined");
    let generator;

    if (named.length === 0) {
      [generator] = found;
    } else {
      const asked = readPreset(resource);

      if (!asked) {
        return undefined;
      }

      generator = named.find((one) => one.name === asked);

      if (!generator) {
        compilation.errors.push(
          MinimizerPlugin.buildError(
            new Error(
              `Error with '${resource}': no '${asked}' preset in \`generate\`, which defines ${named.map((one) => `'${one.name}'`).join(", ")}.`,
            ),
            resource,
          ),
        );

        return undefined;
      }
    }

    // An `asset` generator runs over what is emitted, so nothing imports it
    // and `?as=` cannot reach it.
    if (!generator || generator.type === "asset") {
      return undefined;
    }

    return {
      implementation: generator.implementation,
      options: generator.options,
    };
  }

  /**
   * Whether any generator rewrites a module as it builds. Only that kind needs
   * `processResult` to be able to await; an `asset` generator does not.
   * @private
   * @returns {boolean} true when one does
   */
  hasModuleGenerator() {
    return this.generators().some((one) => one.type !== "asset");
  }

  /**
   * Every name the functions this plugin runs mark an asset with, which is
   * what stats have to know how to print.
   * @private
   * @returns {Set<string>} the names
   */
  assetFlags() {
    const flags = new Set();

    for (const flag of declaredFlags(
      this.options.minimizer.implementation,
      "minimized",
    )) {
      flags.add(flag);
    }

    // Only the generators that write a file: an `import` one rewrites a module
    // as it builds and marks no asset.
    for (const generator of this.assetGenerators()) {
      for (const flag of declaredFlags(generator.implementation, "generated")) {
        flags.add(flag);
      }
    }

    return flags;
  }

  /**
   * Every name this plugin's `asset` generators mark what they wrote with,
   * which is how both passes tell a generated file from one to work on.
   * @private
   * @returns {string[]} the names
   */
  generatedFlags() {
    /** @type {string[]} */
    const flags = [];

    for (const one of this.assetGenerators()) {
      for (const flag of declaredFlags(one.implementation, "generated")) {
        if (!flags.includes(flag)) {
          flags.push(flag);
        }
      }
    }

    return flags;
  }

  /**
   * The generators that run over emitted assets rather than over a module as
   * it builds.
   * @private
   * @returns {ReturnType<MinimizerPlugin["describeGenerator"]>[]} them, in the order they were written
   */
  assetGenerators() {
    return this.generators().filter((one) => one.type === "asset");
  }

  /**
   * Carries the generator's identity into the persistent cache's version.
   * A generator rewrites a module's own build result, which the pack restores
   * without rebuilding, and nothing per-module keys on a plugin.
   * @private
   * @param {Compiler} compiler compiler
   * @returns {void}
   */
  saltCacheVersion(compiler) {
    const { generator } = this.options;
    const { cache } = compiler.options;

    if (!generator || !cache || cache.type !== "filesystem") {
      return;
    }

    // Every generator, its name and how it is run included: which one a build
    // reaches is the asset's to decide, so all are part of the pack's answer.
    const identity = [...this.generators()]
      .sort((a, b) => String(a.name).localeCompare(String(b.name)))
      .map((one) => [
        one.name,
        // Source rather than `getMinimizerVersion`: a generator already
        // travels as source, and a custom one has no version to read.
        (Array.isArray(one.implementation)
          ? one.implementation
          : [one.implementation]
        ).map(String),
        one.type,
        one.filename,
        String(one.filter),
        one.deleteOriginalAssets,
        one.options,
      ]);

    // Salted with the name this plugin shipped under, for the same reason the
    // namespaces are: a rename here would invalidate every pack in the wild.
    cache.version = `${cache.version || ""}|TerserPlugin-generate-${crypto
      .createHash("sha256")
      .update(getSerializeJavascript()(identity))
      .digest("hex")
      .slice(0, 16)}`;
  }

  /**
   * Generate one new asset from one already emitted, leaving the original in
   * place unless the generator asked for it to go.
   * @private
   * @param {Compiler} compiler compiler
   * @param {Compilation} compilation compilation
   * @param {ReturnType<Compilation["getCache"]>} cache the generation cache
   * @param {Asset} asset the asset to generate from
   * @param {ReturnType<MinimizerPlugin["assetGenerators"]>[0]} generator the generator to run
   * @returns {Promise<void>}
   */
  async generateAsset(compiler, compilation, cache, asset, generator) {
    const { RawSource } = compiler.webpack.sources;
    const { name, info, source } = asset;
    // `buffer()` rather than `source()`, which answers a source holding text
    // and bytes at once with a string: every byte over 0x7f is lost in that.
    const input = source.buffer();
    const says = /** @type {Record<string, EXPECTED_ANY>} */ (info);

    // Too small to be worth a second file, and one already recorded under this
    // generator's key has been through it.
    if (
      input.length < (generator.threshold || 0) ||
      (generator.relatedName &&
        says.related &&
        says.related[generator.relatedName])
    ) {
      return;
    }

    // The generator is in the item's name rather than its etag: two presets
    // reading the same asset must not answer for one another.
    const cacheItem = cache.getItemCache(
      getSerializeJavascript()({
        name,
        generator: String(generator.implementation),
        options: generator.options,
      }),
      cache.getLazyHashedEtag(source),
    );
    let output =
      /** @type {{ source: import("webpack").sources.Source, filename?: string, width?: number, height?: number, errors?: (Error | string)[], warnings?: (Error | string)[] } | undefined} */
      (await cacheItem.getPromise());

    if (!output) {
      /** @type {MinimizedResult} */
      let generated;

      try {
        generated = await minify({
          name,
          input,
          inputSourceMap: undefined,
          minimizer: {
            implementation: generator.implementation,
            options: generator.options,
          },
          extractComments: false,
          ecma: getEcmaVersion(
            /** @type {NonNullable<NonNullable<import("webpack").Configuration["output"]>["environment"]>} */
            (compiler.options.output.environment),
          ),
        });
      } catch (error) {
        compilation.errors.push(
          MinimizerPlugin.buildError(
            /** @type {Error | ErrorObject | string} */ (error),
            name,
          ),
        );

        return;
      }

      const code =
        typeof generated.code === "undefined"
          ? input
          : Buffer.isBuffer(generated.code)
            ? generated.code
            : Buffer.from(generated.code);

      output = {
        // The source, not its bytes: webpack re-emits a file whose source it
        // has not seen before, so building a fresh one per rebuild writes an
        // identical file over the old one every time.
        source: new RawSource(code),
        filename: generated.filename,
        width: generated.width,
        height: generated.height,
        errors: (generated.errors || []).map((item) =>
          MinimizerPlugin.buildError(
            /** @type {Error | ErrorObject | string} */ (item),
            name,
          ),
        ),
        warnings: (generated.warnings || []).map((item) =>
          MinimizerPlugin.buildWarning(item, name),
        ),
      };

      await cacheItem.storePromise(output);
    }

    for (const warning of /** @type {Error[]} */ (output.warnings || [])) {
      compilation.warnings.push(warning);
    }

    // A generator that failed hands back whatever it had when it gave up, so
    // writing it would put a wrong file on disk under a right-looking name.
    if (output.errors && output.errors.length > 0) {
      for (const error of /** @type {Error[]} */ (output.errors)) {
        compilation.errors.push(error);
      }

      return;
    }

    const generatedName = generator.filename
      ? interpolateSize(
          compilation.getAssetPath(generator.filename, { filename: name }),
          output,
        )
      : output.filename || name;

    // A size the generator never reported leaves its placeholder standing, and
    // a file named `[width]` is worse than a build that says why.
    if (/\[(width|height)\]/i.test(generatedName)) {
      compilation.errors.push(
        MinimizerPlugin.buildError(
          new Error(
            `Error with '${name}': '${generator.filename}' asks for a size this generator does not report.`,
          ),
          name,
        ),
      );

      return;
    }
    const generatedSource = output.source;

    // Not enough smaller to be worth serving: a second file that saves nothing
    // still costs a request and a place in the cache.
    if (
      typeof generator.minRatio === "number" &&
      generatedSource.size() / input.length > generator.minRatio
    ) {
      return;
    }

    // A new file rather than a rewritten one, so it inherits nothing: what the
    // original's info says of its hashes, its module and where its source came
    // from is true of that file and not of this one.
    /** @type {AssetInfo} */
    const generatedInfo = {};

    // The name this generator works under, which is `generated` where it says
    // nothing and `compressed` for `compress`.
    for (const flag of declaredFlags(generator.implementation, "generated")) {
      /** @type {Record<string, EXPECTED_ANY>} */ (generatedInfo)[flag] = true;
    }

    // The exception, and only where the name it was given still derives from
    // the original's: that is what carried the hash the promise rests on.
    if (
      info.immutable &&
      typeof generator.filename === "string" &&
      /(\[name]|\[base]|\[file])/.test(generator.filename)
    ) {
      generatedInfo.immutable = true;
    }

    // A rebuild writes over the file it wrote last time rather than a new one,
    // and what is recorded below is owed either way.
    if (compilation.getAsset(generatedName)) {
      compilation.updateAsset(generatedName, generatedSource, generatedInfo);
    } else {
      compilation.emitAsset(generatedName, generatedSource, generatedInfo);
    }

    if (generator.deleteOriginalAssets) {
      // Deleting an asset takes everything its `related` names with it, so
      // recording this file there first would delete the file just written.
      if (compilation.getAsset(name)) {
        compilation.deleteAsset(name);
      }

      return;
    }

    // Recorded on the asset it was read from, which is how a server asked for
    // that one finds this one.
    if (generator.relatedName) {
      compilation.updateAsset(name, source, {
        related: { [generator.relatedName]: generatedName },
      });
    }
  }

  /**
   * Generate new assets from the ones already emitted. Where `generate`
   * rewrites a module's own bytes as it builds, this adds a file beside one
   * that is already named, so nothing has to import it.
   * @private
   * @param {Compiler} compiler compiler
   * @param {Compilation} compilation compilation
   * @param {ReturnType<MinimizerPlugin["assetGenerators"]>} generators the generators running at this stage
   * @param {Record<string, import("webpack").sources.Source>} assets the assets this pass was handed
   * @returns {Promise<void>}
   */
  async generateAssets(compiler, compilation, generators, assets) {
    const cache = compilation.getCache("TerserWebpackPlugin|generateAssets");
    const scheduled = [];
    // So no generator reads a file another one wrote, whichever name that one
    // marked it with.
    const produced = this.generatedFlags();

    for (const name of Object.keys(assets)) {
      const asset = compilation.getAsset(name);

      if (!asset || !this.matchesName(compiler, name)) {
        continue;
      }

      const says = /** @type {Record<string, EXPECTED_ANY>} */ (asset.info);

      if (produced.some((flag) => says[flag])) {
        continue;
      }

      for (const generator of generators) {
        if (generator.filter && !generator.filter(name)) {
          continue;
        }

        scheduled.push(
          this.generateAsset(compiler, compilation, cache, asset, generator),
        );
      }
    }

    await Promise.all(scheduled);
  }

  /**
   * Where work runs when nothing asks for anywhere else: after the bundle is
   * rendered and before its hashes are taken, which is where minifying belongs.
   * @private
   * @param {Compiler} compiler compiler
   * @returns {number} the stage
   */
  defaultStage(compiler) {
    return compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE;
  }

  /**
   * Which minimizers run at which `processAssets` stage, as indices into the
   * configured ones. Each runs where its own `getStage` asks to, and they
   * still chain — through the asset, which the later pass reads back.
   * @private
   * @param {Compiler} compiler compiler
   * @returns {Map<number, number[]>} the indices, by stage
   */
  minimizersByStage(compiler) {
    const { implementation } = this.options.minimizer;
    const each = Array.isArray(implementation)
      ? implementation
      : [implementation];
    const fallback = this.defaultStage(compiler);
    /** @type {Map<number, number[]>} */
    const byStage = new Map();

    for (let i = 0; i < each.length; i++) {
      const asked = declaredStage(compiler, each[i]);
      const at = typeof asked === "number" ? asked : fallback;
      const already = byStage.get(at);

      if (already) {
        already.push(i);
      } else {
        byStage.set(at, [i]);
      }
    }

    return byStage;
  }

  /**
   * Minify one source a module embeds in another language's output — CSS or
   * HTML reaching the bundle inside a JavaScript string literal, an
   * `asset/source` file's text, an `asset/inline` payload. No asset carries
   * this text, so there is no filename to dispatch by: it goes to whichever
   * minimizer declares `info.type` among the languages it minifies.
   * @private
   * @param {Compiler} compiler compiler
   * @param {Compilation} compilation compilation
   * @param {import("webpack").sources.Source} variesOn everything the minified answer varies on beyond the source itself
   * @param {import("webpack").sources.Source} source the embedded source
   * @param {EmbeddedSourceInfo} info what it is and where it is going
   * @returns {Promise<import("webpack").sources.Source>} the minified source, or the original
   */
  async renderEmbeddedSource(compiler, compilation, variesOn, source, info) {
    const { type, hostType, module } = info;
    const minimizers = this.minimizers();
    const matched = [];

    // A minimizer that declares nothing takes no embedded source: such source
    // carries no filename to guess from, and guessing is what `getTypes`
    // replaces.
    for (let i = 0; i < minimizers.length; i++) {
      const { getTypes } = minimizers[i];

      if (typeof getTypes === "function" && (getTypes() || []).includes(type)) {
        matched.push(i);
      }
    }

    if (matched.length === 0) {
      return source;
    }

    const name = module.nameForCondition() || module.identifier();

    const cache = compilation.getCache("TerserWebpackPlugin|embeddedSource");
    // The minimizers and their options are in the etag, not just the source:
    // this cache outlives the build, so an entry stored under one set of
    // options must not answer for another.
    const cacheItem = cache.getItemCache(
      `${name}|${type}|${hostType}`,
      cache.mergeEtags(
        cache.getLazyHashedEtag(source),
        cache.getLazyHashedEtag(variesOn),
      ),
    );
    let output =
      /** @type {{ source: import("webpack").sources.Source, errors?: (Error | string)[], warnings?: (Error | string)[] } | undefined} */
      (await cacheItem.getPromise());

    if (!output) {
      const { source: sourceFromInputSource, map } = source.sourceAndMap();
      const input = Buffer.isBuffer(sourceFromInputSource)
        ? sourceFromInputSource.toString()
        : sourceFromInputSource;
      const inputSourceMap =
        map && MinimizerPlugin.isSourceMap(map)
          ? /** @type {RawSourceMap} */ (map)
          : undefined;

      /** @type {MinimizedResult} */
      let result;

      try {
        // Code generation runs before the worker pool is up, so this one is in
        // process. What it embeds in turn is reached by `minify` itself.
        result = await minify({
          name,
          input,
          inputSourceMap,
          // There is no asset to hang a banner on, and no filename to point
          // it at, so comments stay where the minimizer's own defaults keep
          // them.
          extractComments: false,
          minimizer: {
            implementation:
              /** @type {MinimizerImplementation<T>} */
              (/** @type {unknown} */ (matched.map((i) => minimizers[i]))),
            options:
              /** @type {MinimizerOptions<T>} */
              (
                /** @type {unknown} */
                (
                  matched.map((i) =>
                    getMinimizerOptionsAt(this.options.minimizer.options, i),
                  )
                )
              ),
          },
          embedded: this.embeddedMinimizer(matched),
          ecma: getEcmaVersion(
            /** @type {NonNullable<NonNullable<import("webpack").Configuration["output"]>["environment"]>} */
            (compiler.options.output.environment),
          ),
        });
      } catch (error) {
        compilation.errors.push(
          MinimizerPlugin.buildError(
            /** @type {Error | ErrorObject | string} */ (error),
            name,
          ),
        );

        return source;
      }

      const { RawSource, SourceMapSource } = compiler.webpack.sources;
      // A map is asked for only when the input carried one: the generator
      // embedding this inlines a new one as a data URI, which costs more than
      // minifying saves.
      const minified =
        typeof result.code === "string"
          ? inputSourceMap && result.map
            ? new SourceMapSource(
                result.code,
                name,
                /** @type {RawSourceMap} */ (result.map),
                /** @type {string} */ (input),
                inputSourceMap,
                true,
              )
            : new RawSource(result.code)
          : source;

      output = {
        source: minified,
        errors: (result.errors || []).map((item) =>
          MinimizerPlugin.buildError(
            /** @type {Error | ErrorObject | string} */ (item),
            name,
          ),
        ),
        warnings: (result.warnings || []).map((item) =>
          MinimizerPlugin.buildWarning(item, name),
        ),
      };

      await cacheItem.storePromise(output);
    }

    for (const error of /** @type {Error[]} */ (output.errors || [])) {
      compilation.errors.push(error);
    }

    for (const warning of /** @type {Error[]} */ (output.warnings || [])) {
      compilation.warnings.push(warning);
    }

    return output.source;
  }

  /**
   * Rewrite one module's own bytes as it is built, which is where an asset can
   * still be renamed: its emitted name and its hash are both read afterwards,
   * so a re-encoding that changes the format changes the extension with it.
   * `processAssets` is too late for that — the bundle already refers to the
   * name the asset had.
   * @private
   * @param {Compiler} compiler compiler
   * @param {Compilation} compilation compilation
   * @param {import("webpack").sources.Source} variesOn everything the answer varies on beyond the bytes themselves
   * @param {LoaderResult} result what the loaders produced
   * @param {import("webpack").NormalModule} module the module being built
   * @returns {Promise<LoaderResult>} the result, rewritten or as it came
   */
  async generate(compiler, compilation, variesOn, result, module) {
    const resource = module.resource || module.identifier();

    if (!this.options.generator || !this.matchesName(compiler, resource)) {
      return result;
    }

    const generator = this.generatorFor(compilation, resource);

    if (!generator) {
      return result;
    }

    const [code] = result;
    const { RawSource } = compiler.webpack.sources;
    const input = Buffer.isBuffer(code) ? code : Buffer.from(code);
    const cache = compilation.getCache("TerserWebpackPlugin|generate");
    // The generator and its options are in the etag as well as the bytes: this
    // cache outlives the build, so an entry stored under one set of options
    // must not answer for another.
    const cacheItem = cache.getItemCache(
      resource,
      cache.mergeEtags(
        cache.getLazyHashedEtag(new RawSource(input)),
        cache.getLazyHashedEtag(variesOn),
      ),
    );
    let output =
      /** @type {{ code: Buffer, filename?: string, errors?: (Error | string)[], warnings?: (Error | string)[] } | undefined} */
      (await cacheItem.getPromise());

    if (!output) {
      /** @type {MinimizedResult} */
      let minified;

      try {
        // Modules build before the worker pool is up, so this runs in process.
        minified = await minify({
          name: resource,
          input,
          // Images carry none, and a re-encoding would invalidate one anyway.
          inputSourceMap: undefined,
          minimizer: generator,
          extractComments: false,
          ecma: getEcmaVersion(
            /** @type {NonNullable<NonNullable<import("webpack").Configuration["output"]>["environment"]>} */
            (compiler.options.output.environment),
          ),
        });
      } catch (error) {
        compilation.errors.push(
          MinimizerPlugin.buildError(
            /** @type {Error | ErrorObject | string} */ (error),
            resource,
          ),
        );

        return result;
      }

      output = {
        code:
          typeof minified.code === "undefined"
            ? input
            : Buffer.isBuffer(minified.code)
              ? minified.code
              : Buffer.from(minified.code),
        filename: minified.filename,
        errors: (minified.errors || []).map((item) =>
          MinimizerPlugin.buildError(
            /** @type {Error | ErrorObject | string} */ (item),
            resource,
          ),
        ),
        warnings: (minified.warnings || []).map((item) =>
          MinimizerPlugin.buildWarning(item, resource),
        ),
      };

      await cacheItem.storePromise(output);
    }

    for (const error of /** @type {Error[]} */ (output.errors || [])) {
      compilation.errors.push(error);
    }

    for (const warning of /** @type {Error[]} */ (output.warnings || [])) {
      compilation.warnings.push(warning);
    }

    // Naming the asset after what it now is. `assetResource` is serialized with
    // the module, so the rename survives a restore from the persistent cache,
    // which `matchResource` would not.
    if (output.filename && output.filename !== resource) {
      /** @type {{ assetResource?: string }} */
      (module.buildInfo).assetResource = output.filename;
    }

    return [output.code, result[1], result[2]];
  }

  /**
   * The same check as `validateGenerators`, for a minimizer: its options
   * cannot come from `minify` and the deprecated `minimizerOptions` both.
   * @private
   * @returns {void}
   */
  validateMinimizers() {
    // TODO drop this check in the next major release, with the deprecated
    // `minimizerOptions` it is about.
    const { minify, minimizerOptions, terserOptions } = this.rawOptions;
    const declared =
      typeof minimizerOptions === "undefined"
        ? terserOptions
        : minimizerOptions;

    if (typeof declared === "undefined") {
      return;
    }

    const written = Array.isArray(minify) ? minify : [minify];

    for (const [index, one] of written.entries()) {
      const own = isDescriptor(one) ? one.options : undefined;
      const twice = Array.isArray(minify)
        ? getMinimizerOptionsAt(declared, index)
        : declared;

      if (typeof own !== "undefined" && typeof twice !== "undefined") {
        throw new Error(
          Array.isArray(minify)
            ? `The minimizer at \`minify[${index}]\` sets its own \`options\`, and the deprecated \`minimizerOptions\` sets them too. Keep the one in \`minify\`.`
            : "`minify` sets its own `options`, and the deprecated `minimizerOptions` sets them too. Keep the one in `minify`.",
        );
      }
    }
  }

  /**
   * Cross-field checks the schema cannot make: options given twice for one
   * generator, and a `generatorOptions` key naming no generator.
   * @private
   * @returns {void}
   */
  validateGenerators() {
    // TODO drop both checks in the next major release, with the deprecated
    // `generatorOptions` they are about.
    const { generator } = this.options;

    if (!generator) {
      return;
    }

    const written = generator.implementation;
    const declared = generator.options;
    const named = isPresets(written) && !isDescriptor(written);
    const presets =
      /** @type {{ [preset: string]: EXPECTED_ANY }} */
      (/** @type {unknown} */ (written));
    const perPreset =
      /** @type {{ [preset: string]: EXPECTED_ANY }} */
      (declared);

    for (const name of named ? Object.keys(presets) : [undefined]) {
      const entry = typeof name === "undefined" ? written : presets[name];
      const own = isDescriptor(entry) ? entry.options : undefined;
      const twice =
        typeof name === "undefined" ? declared : perPreset && perPreset[name];

      if (typeof own !== "undefined" && typeof twice !== "undefined") {
        throw new Error(
          typeof name === "undefined"
            ? "`generate` sets its own `options`, and the deprecated `generatorOptions` sets them too. Keep the one in `generate`."
            : `The '${name}' generator in \`generate\` sets its own \`options\`, and the deprecated \`generatorOptions.${name}\` sets them too. Keep the one in \`generate\`.`,
        );
      }
    }

    // `filename`, `filter` and `deleteOriginalAssets` describe a file written
    // beside another, which only an `asset` generator does.
    for (const one of this.generators()) {
      const misplaced = [];

      if (one.type !== "asset") {
        if (typeof one.filename !== "undefined") {
          misplaced.push("filename");
        }

        if (typeof one.filter !== "undefined") {
          misplaced.push("filter");
        }

        if (typeof one.deleteOriginalAssets !== "undefined") {
          misplaced.push("deleteOriginalAssets");
        }

        for (const field of ["threshold", "minRatio", "relatedName"]) {
          if (
            typeof (
              /** @type {Record<string, EXPECTED_ANY>} */ (one)[field]
            ) !== "undefined"
          ) {
            misplaced.push(field);
          }
        }
      }

      if (misplaced.length > 0) {
        throw new Error(
          `${misplaced.map((field) => `\`${field}\``).join(" and ")} in \`generate\`${
            typeof one.name === "undefined" ? "" : `'s '${one.name}'`
          } ${misplaced.length === 1 ? "belongs" : "belong"} to a generator with \`type: "asset"\`, which writes a file beside the one it read. An \`import\` generator renames the module it re-encodes and reads neither.`,
        );
      }
    }

    if (!named || !isPresets(declared)) {
      return;
    }

    for (const name of Object.keys(perPreset)) {
      if (!Object.prototype.hasOwnProperty.call(presets, name)) {
        throw new Error(
          `\`generatorOptions.${name}\` names no generator in \`generate\`, which defines ${Object.keys(
            presets,
          )
            .map((one) => `'${one}'`)
            .join(", ")}.`,
        );
      }
    }
  }

  /**
   * Validates the options the plugin was constructed with.
   * @private
   * @param {Compiler} compiler compiler
   * @returns {void}
   */
  validateOptions(compiler) {
    if (typeof compiler.validate === "function") {
      compiler.validate(
        () => /** @type {Schema} */ (require("./options.json")),
        this.rawOptions,
        VALIDATION_CONFIGURATION,
      );
      this.validateMinimizers();
      this.validateGenerators();

      return;
    }

    // TODO remove in the next major release, when webpack >= 5.106 is the
    // minimum and `compiler.validate` is always there.
    const { validate } = require("schema-utils");

    validate(
      /** @type {Schema} */ (require("./options.json")),
      this.rawOptions,
      VALIDATION_CONFIGURATION,
    );
    this.validateMinimizers();
    this.validateGenerators();
  }

  /**
   * @param {Compiler} compiler compiler
   * @returns {void}
   */
  apply(compiler) {
    const pluginName = this.constructor.name;

    this.saltCacheVersion(compiler);

    let validated = false;
    const validateOptions = () => {
      if (validated) {
        return;
      }

      validated = true;
      this.validateOptions(compiler);
    };

    if (compiler.hooks.validate) {
      compiler.hooks.validate.tap(pluginName, validateOptions);
    }

    // TODO remove in the next major release, once every supported webpack calls
    // `validate` after it applies `optimization.minimizer`. Until then that hook
    // reaches this plugin only where it sits in `plugins`, and webpack < 5.106
    // has no such hook at all; `initialize` runs after either placement.
    compiler.hooks.initialize.tap(pluginName, validateOptions);

    const availableNumberOfCores = MinimizerPlugin.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) => {
        const willBe = chunkAssetName(compilation, chunk);

        // A chunk this instance was never pointed at cannot vary with its
        // minimizers, so salting it would rename a file it never rewrites. A
        // `filter` is not asked: it reads an asset's info, which no asset has
        // yet, and guessing one could skip the salt for an asset it then takes.
        if (typeof willBe === "string" && !this.matchesName(compiler, willBe)) {
          return;
        }

        // The salt is the name this plugin shipped under, and every
        // `[fullhash]` is taken over it: renaming it would rename every file.
        hash.update("TerserPlugin");
        hash.update(data);
      });

      // Added in webpack 5.110: source one language embeds in another, which no
      // asset carries and `processAssets` therefore never sees.
      const embeddedHooks =
        /** @type {EmbeddedSourceHooks} */
        (/** @type {unknown} */ (compilation.hooks));

      if (
        embeddedHooks.renderEmbeddedSource &&
        embeddedHooks.embeddedSourceHash
      ) {
        // Wrapped once so the etag it yields is computed once per build.
        const variesOn = new compiler.webpack.sources.RawSource(data);

        embeddedHooks.renderEmbeddedSource.tapPromise(
          pluginName,
          (source, info) =>
            this.renderEmbeddedSource(
              compiler,
              compilation,
              variesOn,
              source,
              info,
            ),
        );
        // Module hashes are taken before code generation, so what this tap
        // varies on cannot reach the code generation cache key on its own.
        embeddedHooks.embeddedSourceHash.tap(pluginName, (module, hash) => {
          hash.update("TerserPlugin");
          hash.update(data);
        });
      }

      const moduleGenerator = this.hasModuleGenerator()
        ? this.options.generator
        : undefined;

      if (moduleGenerator) {
        const generatorData = getSerializeJavascript()({
          generator: Array.isArray(moduleGenerator.implementation)
            ? moduleGenerator.implementation.map(getVersion)
            : getVersion(
                /** @type {BasicMinimizerImplementation<EXPECTED_ANY> & MinimizeFunctionHelpers} */
                (moduleGenerator.implementation),
              ),
          options: moduleGenerator.options,
        });
        const variesOn = new compiler.webpack.sources.RawSource(generatorData);
        const moduleHooks =
          /** @type {AwaitableModuleHooks} */
          (
            /** @type {unknown} */
            (compiler.webpack.NormalModule.getCompilationHooks(compilation))
          );

        try {
          moduleHooks.processResult.tapPromise(pluginName, (result, module) =>
            this.generate(compiler, compilation, variesOn, result, module),
          );
        } catch (error) {
          // Before webpack 5.110 the hook is a `SyncWaterfallHook`, which
          // rejects a promise tap. Nothing here can run without awaiting.
          compilation.errors.push(
            MinimizerPlugin.buildError(
              new Error(
                `The \`generate\` option needs a webpack whose \`NormalModule\` \`processResult\` hook can await (>= 5.111); this one cannot: ${
                  /** @type {Error} */ (error).message
                }`,
              ),
              pluginName,
            ),
          );
        }
      }

      const fallback = this.defaultStage(compiler);

      const minimizersByStage = this.minimizersByStage(compiler);
      // What this plugin wrote onto each asset in this compilation, so a later
      // pass reads the asset back rather than taking the flag for a child
      // compilation's work.
      /** @type {Map<string, Set<string>>} */
      const written = new Map();

      for (const [at, only] of minimizersByStage) {
        compilation.hooks.processAssets.tapPromise(
          { name: pluginName, stage: at, additionalAssets: true },
          (assets) =>
            this.optimize(compiler, compilation, assets, {
              availableNumberOfCores,
              only,
              written,
              // Only where a second pass exists to be confused with: one pass
              // keeps the cache keys every earlier release wrote.
              cacheSuffix: minimizersByStage.size > 1 ? `|${at}` : "",
            }),
        );
      }

      // One tap per stage the generators asked for: a file written beside a
      // minified asset and one written beside a compressed asset are the same
      // work at two different moments of `processAssets`.
      /** @type {Map<number, ReturnType<MinimizerPlugin["assetGenerators"]>>} */
      const generatorsByStage = new Map();

      for (const generator of this.assetGenerators()) {
        const asked = declaredStage(compiler, generator.implementation);
        const at = typeof asked === "number" ? asked : fallback;
        const already = generatorsByStage.get(at);

        if (already) {
          already.push(generator);
        } else {
          generatorsByStage.set(at, [generator]);
        }
      }

      for (const [at, generators] of generatorsByStage) {
        compilation.hooks.processAssets.tapPromise(
          { name: pluginName, stage: at, additionalAssets: true },
          (assets) =>
            this.generateAssets(compiler, compilation, generators, assets),
        );
      }

      compilation.hooks.statsPrinter.tap(pluginName, (stats) => {
        // Whatever the functions this plugin runs work under, rather than the
        // names this file happens to know: one naming itself prints itself.
        for (const flag of this.assetFlags()) {
          stats.hooks.print
            .for(`asset.info.${flag}`)
            .tap("minimizer-webpack-plugin", (marked, { green, formatFlag }) =>
              marked
                ? /** @type {(text: string) => string} */ (green)(
                    /** @type {(flag: string) => string} */ (formatFlag)(flag),
                  )
                : "",
            );
        }
      });
    });
  }
}

MinimizerPlugin.terserMinify = terserMinify;
MinimizerPlugin.uglifyJsMinify = uglifyJsMinify;
MinimizerPlugin.swcMinify = swcMinify;
MinimizerPlugin.esbuildMinify = esbuildMinify;
MinimizerPlugin.jsonMinify = jsonMinify;
MinimizerPlugin.htmlMinifierTerser = htmlMinifierTerser;
MinimizerPlugin.swcMinifyHtml = swcMinifyHtml;
MinimizerPlugin.swcMinifyHtmlFragment = swcMinifyHtmlFragment;
MinimizerPlugin.minifyHtmlNode = minifyHtmlNode;
MinimizerPlugin.cssnanoMinify = cssnanoMinify;
MinimizerPlugin.cssoMinify = cssoMinify;
MinimizerPlugin.cleanCssMinify = cleanCssMinify;
MinimizerPlugin.esbuildMinifyCss = esbuildMinifyCss;
MinimizerPlugin.lightningCssMinify = lightningCssMinify;
MinimizerPlugin.swcMinifyCss = swcMinifyCss;
MinimizerPlugin.imageminGenerate = imageminGenerate;
MinimizerPlugin.imageminMinify = imageminMinify;
MinimizerPlugin.imageminNormalizeConfig = imageminNormalizeConfig;
MinimizerPlugin.napiRsImageMinify = napiRsImageMinify;
MinimizerPlugin.sharpMinify = sharpMinify;
MinimizerPlugin.sharpGenerate = sharpGenerate;
MinimizerPlugin.svgoMinify = svgoMinify;
MinimizerPlugin.compress = compress;

module.exports = MinimizerPlugin;