@rushstack/webpack5-module-minifier-plugin 5.6.14 → 5.8.0

package/lib-esm/Constants.js

@@ -0,0 +1,56 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+/**
+ * Prefix to wrap `function (module, __webpack_exports__, __webpack_require__) { ... }` so that the minifier doesn't delete it.
+ * Public because alternate Minifier implementations may wish to know about it.
+ * @public
+ */
+export const MODULE_WRAPPER_PREFIX = '__MINIFY_MODULE__(';
+/**
+ * Suffix to wrap `function (module, __webpack_exports__, __webpack_require__) { ... }` so that the minifier doesn't delete it.
+ * Public because alternate Minifier implementations may wish to know about it.
+ * @public
+ */
+export const MODULE_WRAPPER_SUFFIX = ');';
+/**
+ * Prefix to wrap ECMAScript method shorthand `(module, __webpack_exports__, __webpack_require__) { ... }` so that the minifier doesn't delete it.
+ * Used when webpack emits modules using shorthand syntax.
+ * Combined with the suffix, creates: `__MINIFY_MODULE__({__DEFAULT_ID__(params){body}});`
+ * Public because alternate Minifier implementations may wish to know about it.
+ * @public
+ */
+export const MODULE_WRAPPER_SHORTHAND_PREFIX = `${MODULE_WRAPPER_PREFIX}{__DEFAULT_ID__`;
+/**
+ * Suffix to wrap ECMAScript method shorthand `(module, __webpack_exports__, __webpack_require__) { ... }` so that the minifier doesn't delete it.
+ * Used when webpack emits modules using shorthand syntax.
+ * Combined with the prefix, creates: `__MINIFY_MODULE__({__DEFAULT_ID__(params){body}});`
+ * Public because alternate Minifier implementations may wish to know about it.
+ * @public
+ */
+export const MODULE_WRAPPER_SHORTHAND_SUFFIX = `}${MODULE_WRAPPER_SUFFIX}`;
+/**
+ * Token preceding a module id in the emitted asset so the minifier can operate on the Webpack runtime or chunk boilerplate in isolation
+ * @public
+ */
+export const CHUNK_MODULE_TOKEN = '__WEBPACK_CHUNK_MODULE__';
+/**
+ * RegExp for replacing chunk module placeholders
+ * Handles three possible representations:
+ * - `"id":__WEBPACK_CHUNK_MODULE__HASH__` (methodShorthand: false, object)
+ * - `__WEBPACK_CHUNK_MODULE__HASH__` (array syntax)
+ * - `"id":__WEBPACK_CHUNK_MODULE__HASH__` with leading ':' (methodShorthand: true, object)
+ * Captures optional leading `:` to handle shorthand format properly
+ * @public
+ */
+export const CHUNK_MODULE_REGEX = /(:?)__WEBPACK_CHUNK_MODULE__([A-Za-z0-9$_]+)/g;
+/**
+ * Stage # to use when this should be the first tap in the hook
+ * @public
+ */
+export const STAGE_BEFORE = -10000;
+/**
+ * Stage # to use when this should be the last tap in the hook
+ * @public
+ */
+export const STAGE_AFTER = 100;
+//# sourceMappingURL=Constants.js.map

package/lib-esm/Constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Constants.js","sourceRoot":"","sources":["../src/Constants.ts"],"names":[],"mappings":"AAAA,4FAA4F;AAC5F,2DAA2D;AAE3D;;;;GAIG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAyB,oBAAoB,CAAC;AAChF;;;;GAIG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAS,IAAI,CAAC;AAEhD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAqD,GAAG,qBAAqB,iBAAiB,CAAC;AAC3I;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAuC,IAAI,qBAAqB,EAAE,CAAC;AAE/G;;;GAGG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAA+B,0BAA0B,CAAC;AAEzF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAW,+CAA+C,CAAC;AAE1F;;;GAGG;AACH,MAAM,CAAC,MAAM,YAAY,GAAW,CAAC,KAAK,CAAC;AAC3C;;;GAGG;AACH,MAAM,CAAC,MAAM,WAAW,GAAQ,GAAG,CAAC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\n/**\n * Prefix to wrap `function (module, __webpack_exports__, __webpack_require__) { ... }` so that the minifier doesn't delete it.\n * Public because alternate Minifier implementations may wish to know about it.\n * @public\n */\nexport const MODULE_WRAPPER_PREFIX: '__MINIFY_MODULE__(' = '__MINIFY_MODULE__(';\n/**\n * Suffix to wrap `function (module, __webpack_exports__, __webpack_require__) { ... }` so that the minifier doesn't delete it.\n * Public because alternate Minifier implementations may wish to know about it.\n * @public\n */\nexport const MODULE_WRAPPER_SUFFIX: ');' = ');';\n\n/**\n * Prefix to wrap ECMAScript method shorthand `(module, __webpack_exports__, __webpack_require__) { ... }` so that the minifier doesn't delete it.\n * Used when webpack emits modules using shorthand syntax.\n * Combined with the suffix, creates: `__MINIFY_MODULE__({__DEFAULT_ID__(params){body}});`\n * Public because alternate Minifier implementations may wish to know about it.\n * @public\n */\nexport const MODULE_WRAPPER_SHORTHAND_PREFIX: `${typeof MODULE_WRAPPER_PREFIX}{__DEFAULT_ID__` = `${MODULE_WRAPPER_PREFIX}{__DEFAULT_ID__`;\n/**\n * Suffix to wrap ECMAScript method shorthand `(module, __webpack_exports__, __webpack_require__) { ... }` so that the minifier doesn't delete it.\n * Used when webpack emits modules using shorthand syntax.\n * Combined with the prefix, creates: `__MINIFY_MODULE__({__DEFAULT_ID__(params){body}});`\n * Public because alternate Minifier implementations may wish to know about it.\n * @public\n */\nexport const MODULE_WRAPPER_SHORTHAND_SUFFIX: `}${typeof MODULE_WRAPPER_SUFFIX}` = `}${MODULE_WRAPPER_SUFFIX}`;\n\n/**\n * Token preceding a module id in the emitted asset so the minifier can operate on the Webpack runtime or chunk boilerplate in isolation\n * @public\n */\nexport const CHUNK_MODULE_TOKEN: '__WEBPACK_CHUNK_MODULE__' = '__WEBPACK_CHUNK_MODULE__';\n\n/**\n * RegExp for replacing chunk module placeholders\n * Handles three possible representations:\n * - `\"id\":__WEBPACK_CHUNK_MODULE__HASH__` (methodShorthand: false, object)\n * - `__WEBPACK_CHUNK_MODULE__HASH__` (array syntax)\n * - `\"id\":__WEBPACK_CHUNK_MODULE__HASH__` with leading ':' (methodShorthand: true, object)\n * Captures optional leading `:` to handle shorthand format properly\n * @public\n */\nexport const CHUNK_MODULE_REGEX: RegExp = /(:?)__WEBPACK_CHUNK_MODULE__([A-Za-z0-9$_]+)/g;\n\n/**\n * Stage # to use when this should be the first tap in the hook\n * @public\n */\nexport const STAGE_BEFORE: -10000 = -10000;\n/**\n * Stage # to use when this should be the last tap in the hook\n * @public\n */\nexport const STAGE_AFTER: 100 = 100;\n"]}

package/lib-esm/GenerateLicenseFileForAsset.js

@@ -0,0 +1,47 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+import * as path from 'node:path';
+function getAllComments(modules) {
+    var _a;
+    const allComments = new Set();
+    for (const webpackModule of modules) {
+        const submodules = (webpackModule.context === null &&
+            webpackModule._modules) || [webpackModule];
+        for (const submodule of submodules) {
+            const subModuleComments = (_a = submodule.factoryMeta) === null || _a === void 0 ? void 0 : _a.comments;
+            if (subModuleComments) {
+                for (const comment of subModuleComments) {
+                    const value = comment.type === 'Line' ? `//${comment.value}\n` : `/*${comment.value}*/\n`;
+                    allComments.add(value);
+                }
+            }
+        }
+    }
+    return allComments;
+}
+/**
+ * Generates a companion asset containing all extracted comments. If it is non-empty, returns a banner comment directing users to said companion asset.
+ *
+ * @param compilation - The webpack compilation
+ * @param asset - The asset to process
+ * @public
+ */
+export function generateLicenseFileForAsset(compilation, asset) {
+    // Extracted comments from the modules.
+    const modules = compilation.chunkGraph.getChunkModulesIterable(asset.chunk);
+    const comments = getAllComments(modules);
+    const assetName = asset.fileName;
+    let banner = '';
+    if (comments.size) {
+        // There are license comments in this chunk, so generate the companion file and inject a banner
+        const licenseSource = new compilation.compiler.webpack.sources.ConcatSource();
+        comments.forEach((comment) => {
+            licenseSource.add(comment);
+        });
+        const licenseFileName = `${assetName}.LICENSE.txt`;
+        compilation.emitAsset(licenseFileName, licenseSource);
+        banner = `/*! For license information please see ${path.basename(licenseFileName)} */\n`;
+    }
+    return banner;
+}
+//# sourceMappingURL=GenerateLicenseFileForAsset.js.map

package/lib-esm/GenerateLicenseFileForAsset.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GenerateLicenseFileForAsset.js","sourceRoot":"","sources":["../src/GenerateLicenseFileForAsset.ts"],"names":[],"mappings":"AAAA,4FAA4F;AAC5F,2DAA2D;AAE3D,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAOlC,SAAS,cAAc,CAAC,OAAyB;;IAC/C,MAAM,WAAW,GAAgB,IAAI,GAAG,EAAE,CAAC;IAE3C,KAAK,MAAM,aAAa,IAAI,OAAO,EAAE,CAAC;QACpC,MAAM,UAAU,GAAqB,CAAC,aAAa,CAAC,OAAO,KAAK,IAAI;YACjE,aAAiD,CAAC,QAAQ,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QAClF,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;YACnC,MAAM,iBAAiB,GAAkC,MACvD,SAAS,CAAC,WAGX,0CAAE,QAAQ,CAAC;YAEZ,IAAI,iBAAiB,EAAE,CAAC;gBACtB,KAAK,MAAM,OAAO,IAAI,iBAAiB,EAAE,CAAC;oBACxC,MAAM,KAAK,GAAW,OAAO,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,KAAK,MAAM,CAAC;oBAClG,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;gBACzB,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,WAAW,CAAC;AACrB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,2BAA2B,CAAC,WAAwB,EAAE,KAAiB;IACrF,uCAAuC;IACvC,MAAM,OAAO,GAAqB,WAAW,CAAC,UAAU,CAAC,uBAAuB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC9F,MAAM,QAAQ,GAAgB,cAAc,CAAC,OAAO,CAAC,CAAC;IAEtD,MAAM,SAAS,GAAW,KAAK,CAAC,QAAQ,CAAC;IAEzC,IAAI,MAAM,GAAW,EAAE,CAAC;IAExB,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC;QAClB,+FAA+F;QAC/F,MAAM,aAAa,GAAyB,IAAI,WAAW,CAAC,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC;QACpG,QAAQ,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;YAC3B,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAC7B,CAAC,CAAC,CAAC;QACH,MAAM,eAAe,GAAW,GAAG,SAAS,cAAc,CAAC;QAC3D,WAAW,CAAC,SAAS,CAAC,eAAe,EAAE,aAAa,CAAC,CAAC;QACtD,MAAM,GAAG,0CAA0C,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,OAAO,CAAC;IAC3F,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\nimport * as path from 'node:path';\n\nimport type { Comment } from 'estree';\nimport type { Compilation, Module, sources } from 'webpack';\n\nimport type { IAssetInfo } from './ModuleMinifierPlugin.types';\n\nfunction getAllComments(modules: Iterable<Module>): Set<string> {\n  const allComments: Set<string> = new Set();\n\n  for (const webpackModule of modules) {\n    const submodules: Iterable<Module> = (webpackModule.context === null &&\n      (webpackModule as { _modules?: Iterable<Module> })._modules) || [webpackModule];\n    for (const submodule of submodules) {\n      const subModuleComments: Iterable<Comment> | undefined = (\n        submodule.factoryMeta as {\n          comments?: Iterable<Comment>;\n        }\n      )?.comments;\n\n      if (subModuleComments) {\n        for (const comment of subModuleComments) {\n          const value: string = comment.type === 'Line' ? `//${comment.value}\\n` : `/*${comment.value}*/\\n`;\n          allComments.add(value);\n        }\n      }\n    }\n  }\n\n  return allComments;\n}\n\n/**\n * Generates a companion asset containing all extracted comments. If it is non-empty, returns a banner comment directing users to said companion asset.\n *\n * @param compilation - The webpack compilation\n * @param asset - The asset to process\n * @public\n */\nexport function generateLicenseFileForAsset(compilation: Compilation, asset: IAssetInfo): string {\n  // Extracted comments from the modules.\n  const modules: Iterable<Module> = compilation.chunkGraph.getChunkModulesIterable(asset.chunk);\n  const comments: Set<string> = getAllComments(modules);\n\n  const assetName: string = asset.fileName;\n\n  let banner: string = '';\n\n  if (comments.size) {\n    // There are license comments in this chunk, so generate the companion file and inject a banner\n    const licenseSource: sources.ConcatSource = new compilation.compiler.webpack.sources.ConcatSource();\n    comments.forEach((comment) => {\n      licenseSource.add(comment);\n    });\n    const licenseFileName: string = `${assetName}.LICENSE.txt`;\n    compilation.emitAsset(licenseFileName, licenseSource);\n    banner = `/*! For license information please see ${path.basename(licenseFileName)} */\\n`;\n  }\n\n  return banner;\n}\n"]}

package/lib-esm/ModuleMinifierPlugin.js

@@ -0,0 +1,458 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+import { createHash } from 'node:crypto';
+import { AsyncSeriesWaterfallHook, SyncWaterfallHook } from 'tapable';
+import { getIdentifier } from '@rushstack/module-minifier';
+import { CHUNK_MODULE_TOKEN, MODULE_WRAPPER_PREFIX, MODULE_WRAPPER_SUFFIX, MODULE_WRAPPER_SHORTHAND_PREFIX, MODULE_WRAPPER_SHORTHAND_SUFFIX, STAGE_BEFORE, STAGE_AFTER } from './Constants';
+import { generateLicenseFileForAsset } from './GenerateLicenseFileForAsset';
+import { rehydrateAsset } from './RehydrateAsset';
+// The name of the plugin, for use in taps
+const PLUGIN_NAME = 'ModuleMinifierPlugin';
+// Monotonically increasing identifier to be incremented any time the code generation logic changes
+// Will be applied to the webpack hash.
+const CODE_GENERATION_REVISION = 1;
+// Match behavior of terser's "some" option
+// https://github.com/terser/terser/blob/d3d924fa9e4c57bbe286b811c6068bcc7026e902/lib/output.js#L175
+const LICENSE_COMMENT_REGEX = /@preserve|@lic|@cc_on|^\**!/i;
+const TAP_BEFORE = {
+    name: PLUGIN_NAME,
+    stage: STAGE_BEFORE
+};
+const TAP_AFTER = {
+    name: PLUGIN_NAME,
+    stage: STAGE_AFTER
+};
+const compilationMetadataMap = new WeakMap();
+function hashCodeFragment(code) {
+    return createHash('sha256').update(code).digest('hex');
+}
+/**
+ * Base implementation of asset rehydration
+ *
+ * @param dehydratedAssets The dehydrated assets
+ * @param compilation The webpack compilation
+ */
+function defaultRehydrateAssets(dehydratedAssets, compilation) {
+    const { assets, modules } = dehydratedAssets;
+    const compilationMetadata = compilationMetadataMap.get(compilation);
+    if (!compilationMetadata) {
+        throw new Error(`Could not get compilation metadata`);
+    }
+    const { metadataByAssetFileName } = compilationMetadata;
+    // Now assets/modules contain fully minified code. Rehydrate.
+    for (const [assetName, info] of assets) {
+        const banner = info.type === 'javascript' ? generateLicenseFileForAsset(compilation, info) : '';
+        const replacementSource = rehydrateAsset(compilation, info, modules, banner, true);
+        metadataByAssetFileName.set(assetName, {
+            positionByModuleId: info.renderInfo
+        });
+        compilation.updateAsset(assetName, replacementSource);
+    }
+    return dehydratedAssets;
+}
+function isMinificationResultError(result) {
+    return !!result.error;
+}
+function isLicenseComment(comment) {
+    return LICENSE_COMMENT_REGEX.test(comment.value);
+}
+/**
+ * RegExp for detecting function keyword with optional whitespace
+ */
+const FUNCTION_KEYWORD_REGEX = /function\s*\(/;
+/**
+ * Detects if the module code uses ECMAScript method shorthand format.
+ * Shorthand format would appear when webpack emits object methods without function keyword
+ * For example: `id(params) { body }` instead of `id: function(params) { body }`
+ *
+ * Following the problem statement's recommendation: inspect the rendered code prior to the first `{`
+ * and look for either a `=>` or `function(`. If neither are encountered, assume object shorthand format.
+ *
+ * @param code - The module source code to check
+ * @returns true if the code is in method shorthand format
+ */
+function isMethodShorthandFormat(code) {
+    // Find the position of the first opening brace
+    const firstBraceIndex = code.indexOf('{');
+    if (firstBraceIndex < 0) {
+        // No brace found, not a function format
+        return false;
+    }
+    // Get the code before the first brace
+    const beforeBrace = code.slice(0, firstBraceIndex);
+    // Check if it contains '=>' or 'function('
+    // If it does, it's a regular arrow function or function expression, not shorthand
+    // Use a simple check that handles common whitespace variations
+    if (beforeBrace.includes('=>') || FUNCTION_KEYWORD_REGEX.test(beforeBrace)) {
+        return false;
+    }
+    // If neither '=>' nor 'function(' are found, assume object method shorthand format
+    // ECMAScript method shorthand is used in object literals: { methodName(params){body} }
+    // Webpack emits this as just (params){body} which only works in the object literal context
+    return true;
+}
+/**
+ * Webpack plugin that minifies code on a per-module basis rather than per-asset. The actual minification is handled by the input `minifier` object.
+ * @public
+ */
+export class ModuleMinifierPlugin {
+    constructor(options) {
+        this.hooks = {
+            rehydrateAssets: new AsyncSeriesWaterfallHook(['dehydratedContent', 'compilation']),
+            postProcessCodeFragment: new SyncWaterfallHook(['code', 'context'])
+        };
+        const { minifier, sourceMap } = options;
+        this._optionsForHash = {
+            ...options,
+            minifier: undefined,
+            revision: CODE_GENERATION_REVISION
+        };
+        this._enhancers = [];
+        this.hooks.rehydrateAssets.tap(PLUGIN_NAME, defaultRehydrateAssets);
+        this.minifier = minifier;
+        this._sourceMap = sourceMap;
+    }
+    static getCompilationStatistics(compilation) {
+        return compilationMetadataMap.get(compilation);
+    }
+    apply(compiler) {
+        for (const enhancer of this._enhancers) {
+            enhancer.apply(compiler);
+        }
+        const { options: { devtool, mode }, webpack } = compiler;
+        webpack.Template.numberToIdentifier = getIdentifier;
+        const { CachedSource, ConcatSource, RawSource, ReplaceSource, SourceMapSource } = webpack.sources;
+        // The explicit setting is preferred due to accuracy, but try to guess based on devtool
+        const useSourceMaps = typeof this._sourceMap === 'boolean'
+            ? this._sourceMap
+            : typeof devtool === 'string'
+                ? devtool.endsWith('source-map')
+                : mode === 'production' && devtool !== false;
+        this._optionsForHash.sourceMap = useSourceMaps;
+        const binaryConfig = Buffer.from(JSON.stringify(this._optionsForHash), 'utf-8');
+        compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation, compilationData) => {
+            const { normalModuleFactory } = compilationData;
+            function addCommentExtraction(parser) {
+                parser.hooks.program.tap(PLUGIN_NAME, (program, comments) => {
+                    const relevantComments = comments.filter(isLicenseComment);
+                    if (comments.length > 0) {
+                        // Webpack's typings now restrict the properties on factoryMeta for unknown reasons
+                        const module = parser.state.module;
+                        if (!module.factoryMeta) {
+                            module.factoryMeta = {
+                                comments: relevantComments
+                            };
+                        }
+                        else {
+                            module.factoryMeta.comments = relevantComments;
+                        }
+                    }
+                });
+            }
+            normalModuleFactory.hooks.parser.for('javascript/auto').tap(PLUGIN_NAME, addCommentExtraction);
+            normalModuleFactory.hooks.parser.for('javascript/dynamic').tap(PLUGIN_NAME, addCommentExtraction);
+            normalModuleFactory.hooks.parser.for('javascript/esm').tap(PLUGIN_NAME, addCommentExtraction);
+            /**
+             * Set of local module ids that have been processed.
+             */
+            const submittedModules = new Set();
+            /**
+             * The text and comments of all minified modules.
+             */
+            const minifiedModules = new Map();
+            /**
+             * The text and comments of all minified chunks. Most of these are trivial, but the runtime chunk is a bit larger.
+             */
+            const minifiedAssets = new Map();
+            const metadataByModule = new WeakMap();
+            const metadataByAssetFileName = new Map();
+            const compilationStatistics = {
+                metadataByModule,
+                metadataByAssetFileName
+            };
+            compilationMetadataMap.set(compilation, compilationStatistics);
+            function getOrCreateMetadata(mod) {
+                let moduleStats = metadataByModule.get(mod);
+                if (!moduleStats) {
+                    moduleStats = {
+                        hashByChunk: new Map(),
+                        sizeByHash: new Map()
+                    };
+                    metadataByModule.set(mod, moduleStats);
+                }
+                return moduleStats;
+            }
+            let pendingMinificationRequests = 0;
+            /**
+             * Indicates that all files have been sent to the minifier and therefore that when pending hits 0, assets can be rehydrated.
+             */
+            let allRequestsIssued = false;
+            let resolveMinifyPromise;
+            const postProcessCode = (code, context) => this.hooks.postProcessCodeFragment.call(code, context);
+            /**
+             * Callback to invoke when a file has finished minifying.
+             */
+            function onFileMinified() {
+                if (--pendingMinificationRequests === 0 && allRequestsIssued) {
+                    resolveMinifyPromise();
+                }
+            }
+            const { minifier } = this;
+            let minifierConnection;
+            // Typings for this object are not exposed
+            // eslint-disable-next-line @typescript-eslint/typedef
+            const javascriptHooks = webpack.javascript.JavascriptModulesPlugin.getCompilationHooks(compilation);
+            /**
+             * The minifier needs to know if the module was wrapped in a factory function, because
+             * function (module, exports, require) { // <implementation> }
+             * minifies to nothing. Unfortunately we can't tell by inspection if the output was wrapped or not.
+             * However, the JavaScriptModulesPlugin invokes three hooks in order when rendering a module:
+             * 1) renderModuleContent - Invoked for every module.
+             * 2) renderModuleContainer - Invoked when wrapping a module in a factory.
+             * 3) renderModulePackage - Invoked for every module as the last hook.
+             */
+            let nextModule;
+            const sourceCache = new WeakMap();
+            javascriptHooks.renderModuleContent.tap(TAP_AFTER, (source) => {
+                // Clear the identification state of the current module.
+                nextModule = undefined;
+                return source;
+            });
+            javascriptHooks.renderModuleContainer.tap(TAP_AFTER, (source, mod) => {
+                // Module is being wrapped in a factory, so it is safe for per-module minification
+                // Leave external modules in-place to avoid needing special handling for externals
+                if (mod.context !== null || !mod.externalType) {
+                    nextModule = mod;
+                }
+                return source;
+            });
+            javascriptHooks.renderModulePackage.tap(TAP_AFTER, 
+            /**
+             * Extracts the code for the module and sends it to be minified.
+             */
+            function minifyModule(source, mod, chunkRenderContext) {
+                if (nextModule !== mod) {
+                    // This module is being inlined. Abandon per-module minification.
+                    return source;
+                }
+                const id = compilation.chunkGraph.getModuleId(mod);
+                if (id === null) {
+                    // This module has no id. Abandon per-module minification.
+                    return source;
+                }
+                const metadata = getOrCreateMetadata(mod);
+                const cachedResult = sourceCache.get(source);
+                if (cachedResult) {
+                    metadata.hashByChunk.set(chunkRenderContext.chunk, cachedResult.hash);
+                    return cachedResult.source;
+                }
+                // Get the source code to check its format
+                const sourceCode = source.source().toString();
+                // Detect if this is ECMAScript method shorthand format
+                const isShorthand = isMethodShorthandFormat(sourceCode);
+                // If this module is wrapped in a factory, need to add boilerplate so that the minifier keeps the function
+                const wrapped = isShorthand
+                    ? new ConcatSource(MODULE_WRAPPER_SHORTHAND_PREFIX, source, MODULE_WRAPPER_SHORTHAND_SUFFIX)
+                    : new ConcatSource(MODULE_WRAPPER_PREFIX + '\n', source, '\n' + MODULE_WRAPPER_SUFFIX);
+                const nameForMap = `(modules)/${id}`;
+                const { source: wrappedCodeRaw, map } = useSourceMaps
+                    ? wrapped.sourceAndMap()
+                    : {
+                        source: wrapped.source(),
+                        map: undefined
+                    };
+                const wrappedCode = wrappedCodeRaw.toString();
+                const hash = hashCodeFragment(wrappedCode);
+                metadata.hashByChunk.set(chunkRenderContext.chunk, hash);
+                if (!submittedModules.has(hash)) {
+                    submittedModules.add(hash);
+                    ++pendingMinificationRequests;
+                    minifier.minify({
+                        hash,
+                        code: wrappedCode,
+                        nameForMap: useSourceMaps ? nameForMap : undefined,
+                        externals: undefined
+                    }, (result) => {
+                        if (isMinificationResultError(result)) {
+                            compilation.errors.push(result.error);
+                        }
+                        else {
+                            try {
+                                const { code: minified, map: minifierMap } = result;
+                                const rawOutput = useSourceMaps
+                                    ? new SourceMapSource(minified, // Code
+                                    nameForMap, // File
+                                    minifierMap, // Base source map
+                                    wrappedCode, // Source from before transform
+                                    map, // Source Map from before transform
+                                    true // Remove original source
+                                    )
+                                    : new RawSource(minified);
+                                const unwrapped = new ReplaceSource(rawOutput);
+                                const len = minified.length;
+                                // Trim off the boilerplate used to preserve the factory
+                                // Use different prefix/suffix lengths for shorthand vs regular format
+                                // Capture isShorthand from closure instead of looking it up
+                                if (isShorthand) {
+                                    // For shorthand format: __MINIFY_MODULE__({__DEFAULT_ID__(args){...}});
+                                    // Remove prefix and suffix by their lengths
+                                    unwrapped.replace(0, MODULE_WRAPPER_SHORTHAND_PREFIX.length - 1, '');
+                                    unwrapped.replace(len - MODULE_WRAPPER_SHORTHAND_SUFFIX.length, len - 1, '');
+                                }
+                                else {
+                                    // Regular format: __MINIFY_MODULE__(function(args){...}); or __MINIFY_MODULE__((args)=>{...});
+                                    unwrapped.replace(0, MODULE_WRAPPER_PREFIX.length - 1, '');
+                                    unwrapped.replace(len - MODULE_WRAPPER_SUFFIX.length, len - 1, '');
+                                }
+                                const withIds = postProcessCode(unwrapped, {
+                                    compilation,
+                                    module: mod,
+                                    loggingName: mod.identifier()
+                                });
+                                const cached = new CachedSource(withIds);
+                                const minifiedSize = Buffer.byteLength(cached.source(), 'utf-8');
+                                metadata.sizeByHash.set(hash, minifiedSize);
+                                minifiedModules.set(hash, {
+                                    source: cached,
+                                    module: mod,
+                                    id,
+                                    isShorthand
+                                });
+                            }
+                            catch (err) {
+                                compilation.errors.push(err);
+                            }
+                        }
+                        onFileMinified();
+                    });
+                }
+                // Create token with optional ':' prefix for shorthand modules
+                // For non-shorthand: __WEBPACK_CHUNK_MODULE__hash (becomes "id":__WEBPACK_CHUNK_MODULE__hash in object)
+                // For shorthand: :__WEBPACK_CHUNK_MODULE__hash (becomes "id"__WEBPACK_CHUNK_MODULE__hash, ':' makes it valid property assignment)
+                const tokenPrefix = isShorthand ? ':' : '';
+                const result = new RawSource(`${tokenPrefix}${CHUNK_MODULE_TOKEN}${hash}`);
+                sourceCache.set(source, {
+                    hash,
+                    source: result,
+                    isShorthand
+                });
+                // Return an expression to replace later
+                return result;
+            });
+            // The optimizeChunkModules hook is the last async hook that occurs before chunk rendering
+            compilation.hooks.optimizeChunkModules.tapPromise(PLUGIN_NAME, async () => {
+                minifierConnection = await minifier.connectAsync();
+                submittedModules.clear();
+            });
+            const isJSAsset = /\.[cm]?js(\?.+)?$/;
+            // This should happen before any other tasks that operate during processAssets
+            compilation.hooks.processAssets.tapPromise(TAP_BEFORE, async () => {
+                const { chunkGraph, chunks } = compilation;
+                // Still need to minify the rendered assets
+                for (const chunk of chunks) {
+                    const allChunkModules = chunkGraph.getChunkModulesIterableBySourceType(chunk, 'javascript');
+                    if (!allChunkModules) {
+                        // This chunk does not contain javascript modules
+                        continue;
+                    }
+                    for (const assetName of chunk.files) {
+                        const asset = compilation.assets[assetName];
+                        // Verify that this is a JS asset
+                        if (isJSAsset.test(assetName)) {
+                            ++pendingMinificationRequests;
+                            const { source: wrappedCodeRaw, map } = useSourceMaps
+                                ? asset.sourceAndMap()
+                                : {
+                                    source: asset.source(),
+                                    map: undefined
+                                };
+                            const rawCode = wrappedCodeRaw.toString();
+                            const nameForMap = `(chunks)/${assetName}`;
+                            const hash = hashCodeFragment(rawCode);
+                            minifier.minify({
+                                hash,
+                                code: rawCode,
+                                nameForMap: useSourceMaps ? nameForMap : undefined,
+                                externals: undefined
+                            }, (result) => {
+                                if (isMinificationResultError(result)) {
+                                    compilation.errors.push(result.error);
+                                    // eslint-disable-next-line no-console
+                                    console.error(result.error);
+                                }
+                                else {
+                                    try {
+                                        const { code: minified, map: minifierMap } = result;
+                                        const rawOutput = useSourceMaps
+                                            ? new SourceMapSource(minified, // Code
+                                            nameForMap, // File
+                                            minifierMap !== null && minifierMap !== void 0 ? minifierMap : undefined, // Base source map
+                                            rawCode, // Source from before transform
+                                            map !== null && map !== void 0 ? map : undefined, // Source Map from before transform
+                                            true // Remove original source
+                                            )
+                                            : new RawSource(minified);
+                                        const withIds = postProcessCode(new ReplaceSource(rawOutput), {
+                                            compilation,
+                                            module: undefined,
+                                            loggingName: assetName
+                                        });
+                                        minifiedAssets.set(assetName, {
+                                            source: new CachedSource(withIds),
+                                            chunk,
+                                            fileName: assetName,
+                                            renderInfo: new Map(),
+                                            type: 'javascript'
+                                        });
+                                    }
+                                    catch (err) {
+                                        compilation.errors.push(err);
+                                    }
+                                }
+                                onFileMinified();
+                            });
+                        }
+                        else {
+                            // This isn't a JS asset. Don't try to minify the asset wrapper, though if it contains modules, those might still get replaced with minified versions.
+                            minifiedAssets.set(assetName, {
+                                // Still need to restore ids
+                                source: postProcessCode(new ReplaceSource(asset), {
+                                    compilation,
+                                    module: undefined,
+                                    loggingName: assetName
+                                }),
+                                chunk,
+                                fileName: assetName,
+                                renderInfo: new Map(),
+                                type: 'unknown'
+                            });
+                        }
+                    }
+                }
+                allRequestsIssued = true;
+                if (pendingMinificationRequests) {
+                    await new Promise((resolve) => {
+                        resolveMinifyPromise = resolve;
+                    });
+                }
+                // Handle any error from the minifier.
+                await (minifierConnection === null || minifierConnection === void 0 ? void 0 : minifierConnection.disconnectAsync());
+                // All assets and modules have been minified, hand them off to be rehydrated
+                await this.hooks.rehydrateAssets.promise({
+                    assets: minifiedAssets,
+                    modules: minifiedModules
+                }, compilation);
+            });
+            // Need to update chunk hashes with information from this plugin
+            javascriptHooks.chunkHash.tap(PLUGIN_NAME, (chunk, hash) => {
+                // Apply the options hash
+                hash.update(binaryConfig);
+                // Apply the hash from the minifier
+                if (minifierConnection) {
+                    hash.update(minifierConnection.configHash, 'utf8');
+                }
+            });
+        });
+    }
+}
+//# sourceMappingURL=ModuleMinifierPlugin.js.map