@rushstack/webpack4-module-minifier-plugin 0.9.4

package/LICENSE

@@ -0,0 +1,24 @@
+@rushstack/webpack4-module-minifier-plugin
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,61 @@
+# @rushstack/webpack4-module-minifier-plugin
+
+## Installation
+
+`npm install @rushstack/webpack4-module-minifier-plugin --save-dev`
+
+## Overview
+
+This Webpack plugin performs minification of production assets on a per-module basis, rather than minifying an entire chunk at a time.
+It issues async calls to the minifier for each unique module and each unique set of chunk boilerplate (i.e. the webpack runtime and the structure of the module list).
+This improves minification time by:
+- Avoiding duplicate work for each module that is included in multiple distinct assets/chunks (this is common with async chunks)
+- Handing smaller code chunks to the minifier at a time (AST analysis is superlinear in size of the AST)
+- Even single asset builds will likely still contain multiple modules in the final output, which can be split across available CPU cores
+
+## Use with `[hash]` and `[contenthash]` tokens
+The plugin will do its best to update webpack hashes if changing the direct inputs (`useSourceMap`, `compressAsyncImports` or `usePortableModules`) to the plugin, but if altering the `minifier` property itself, you may need to use the `output.hashSalt` property to force a change to the hashes, especially if leverging the `MessagePortMinifier` or similar, since it has no direct access to the configuration of the minifier.
+
+## Parallel execution
+If running on node 10, you will need to ensure that the `--experimental-workers` flag is enabled.
+
+```js
+const { ModuleMinifierPlugin, WorkerPoolMinifier } = require('@rushstack/webpack4-module-minifier-plugin');
+
+// In your webpack options:
+optimization: {
+  minimizer: [
+    new ModuleMinifierPlugin({
+      minifier: new WorkerPoolMinifier(),
+      // If not provided, the plugin will attempt to guess from `mode` and `devtool`.
+      // Providing it expressly gives better results
+      useSourceMap: true
+    })
+  ]
+}
+```
+
+## Single-threaded execution
+You can also run the ModuleMinifierPlugin in a single-threaded configuration.
+
+```js
+// webpack.config.js
+const { ModuleMinifierPlugin, LocalMinifier } = require('@rushstack/webpack4-module-minifier-plugin');
+
+// In your webpack options:
+optimization: {
+  minimizer: [
+    new ModuleMinifierPlugin({
+      minifier: new LocalMinifier()
+    })
+  ]
+}
+```
+
+## Links
+
+- [CHANGELOG.md](
+  https://github.com/microsoft/rushstack/blob/main/webpack/module-minifier-plugin/CHANGELOG.md) - Find
+  out what's new in the latest version
+
+`@rushstack/webpack4-module-minifier-plugin` is part of the [Rush Stack](https://rushstack.io/) family of projects.

package/dist/tsdoc-metadata.json

@@ -0,0 +1,11 @@
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "7.25.2"
+    }
+  ]
+}

package/dist/webpack4-module-minifier-plugin.d.ts

@@ -0,0 +1,346 @@
+import type { AsyncSeriesWaterfallHook } from 'tapable';
+import { Compiler } from 'webpack';
+import { getIdentifier } from '@rushstack/module-minifier';
+import { ILocalMinifierOptions } from '@rushstack/module-minifier';
+import { IMinifierConnection } from '@rushstack/module-minifier';
+import { IModuleMinificationCallback } from '@rushstack/module-minifier';
+import { IModuleMinificationErrorResult } from '@rushstack/module-minifier';
+import { IModuleMinificationRequest } from '@rushstack/module-minifier';
+import { IModuleMinificationResult } from '@rushstack/module-minifier';
+import { IModuleMinificationSuccessResult } from '@rushstack/module-minifier';
+import { IModuleMinifier } from '@rushstack/module-minifier';
+import { IModuleMinifierFunction } from '@rushstack/module-minifier';
+import { IWorkerPoolMinifierOptions } from '@rushstack/module-minifier';
+import { LocalMinifier } from '@rushstack/module-minifier';
+import { MessagePortMinifier } from '@rushstack/module-minifier';
+import { NoopMinifier } from '@rushstack/module-minifier';
+import { Plugin } from 'webpack';
+import type { ReplaceSource } from 'webpack-sources';
+import { Source } from 'webpack-sources';
+import type { SyncWaterfallHook } from 'tapable';
+import * as webpack from 'webpack';
+import { WorkerPoolMinifier } from '@rushstack/module-minifier';
+
+/**
+ * Token to replace the object or array of module definitions so that the minifier can operate on the Webpack runtime or chunk boilerplate in isolation
+ * @public
+ */
+export declare const CHUNK_MODULES_TOKEN: '__WEBPACK_CHUNK_MODULES__';
+
+/**
+ * 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
+ * @param minifiedModules - The minified modules to pull comments from
+ * @param assetName - The name of the asset
+ * @public
+ */
+export declare function generateLicenseFileForAsset(compilation: webpack.compilation.Compilation, asset: IAssetInfo, minifiedModules: IModuleMap): string;
+
+export { getIdentifier }
+
+/**
+ * The comment objects from the Acorn parser inside of webpack
+ * @internal
+ */
+export declare interface _IAcornComment {
+    type: 'Line' | 'Block';
+    value: string;
+    start: number;
+    end: number;
+}
+
+/**
+ * Information about a dehydrated webpack ECMAScript asset
+ * @public
+ */
+export declare interface IAssetInfo {
+    /**
+     * The (minified) boilerplate code for the asset. Will contain a token to be replaced by the minified modules.
+     */
+    source: Source;
+    /**
+     * The name of the asset, used to index into compilation.assets
+     */
+    fileName: string;
+    /**
+     * The ids of the modules that are part of the chunk corresponding to this asset
+     */
+    modules: (string | number)[];
+    /**
+     * The raw chunk object from Webpack, in case information from it is necessary for reconstruction
+     */
+    chunk: webpack.compilation.Chunk;
+    /**
+     * The set of external names to postprocess
+     */
+    externalNames: Map<string, string>;
+}
+
+/**
+ * A map from file names to dehydrated assets
+ * @public
+ */
+export declare type IAssetMap = Map<string, IAssetInfo>;
+
+/**
+ * The set of data remaining to rehydrate in the current compilation
+ * @public
+ */
+export declare interface IDehydratedAssets {
+    /**
+     * The set of remaining assets to rehydrate. Each tap may remove some or all assets from this collection
+     */
+    assets: IAssetMap;
+    /**
+     * The set of modules to use for rehydrating assets.
+     */
+    modules: IModuleMap;
+}
+
+/**
+ * Extension of the webpack Module typings with members that are used by this Plugin
+ * @public
+ */
+export declare interface IExtendedModule extends webpack.compilation.Module {
+    /**
+     * Is this module external?
+     */
+    external?: boolean;
+    /**
+     * Concatenated modules
+     */
+    modules?: IExtendedModule[];
+    /**
+     * Recursively scan the dependencies of a module
+     */
+    hasDependencies(callback: (dep: webpack.compilation.Dependency) => boolean | void): boolean;
+    /**
+     * Id for the module
+     */
+    id: string | number | null;
+    /**
+     * Gets a descriptive identifier for the module.
+     */
+    identifier(): string;
+    /**
+     * Gets a friendly identifier for the module.
+     */
+    readableIdentifier(requestShortener: unknown): string;
+    /**
+     * Path to the physical file this module represents
+     */
+    resource?: string;
+}
+
+export { ILocalMinifierOptions }
+
+export { IMinifierConnection }
+
+/**
+ * Information about a minified module
+ * @public
+ */
+export declare interface IModuleInfo {
+    /**
+     * The (minified) code of this module. Will be a function expression.
+     */
+    source: Source;
+    /**
+     * The raw module object from Webpack, in case information from it is necessary for reconstruction
+     */
+    module: IExtendedModule;
+}
+
+/**
+ * A map from module ids to minified modules
+ * @public
+ */
+export declare type IModuleMap = Map<string | number, IModuleInfo>;
+
+export { IModuleMinificationCallback }
+
+export { IModuleMinificationErrorResult }
+
+export { IModuleMinificationRequest }
+
+export { IModuleMinificationResult }
+
+export { IModuleMinificationSuccessResult }
+
+export { IModuleMinifier }
+
+export { IModuleMinifierFunction }
+
+/**
+ * Hooks provided by the ModuleMinifierPlugin
+ * @public
+ */
+export declare interface IModuleMinifierPluginHooks {
+    /**
+     * Hook invoked at the start of optimizeChunkAssets to rehydrate the minified boilerplate and runtime into chunk assets.
+     */
+    rehydrateAssets: AsyncSeriesWaterfallHook<IDehydratedAssets, webpack.compilation.Compilation>;
+    /**
+     * Hook invoked on a module id to get the final rendered id.
+     */
+    finalModuleId: SyncWaterfallHook<string | number | undefined, webpack.compilation.Compilation>;
+    /**
+     * Hook invoked on code after it has been returned from the minifier.
+     */
+    postProcessCodeFragment: SyncWaterfallHook<ReplaceSource, IPostProcessFragmentContext>;
+}
+
+/**
+ * Options to the ModuleMinifierPlugin constructor
+ * @public
+ */
+export declare interface IModuleMinifierPluginOptions {
+    /**
+     * Minifier implementation to use. Required.
+     */
+    minifier: IModuleMinifier;
+    /**
+     * Whether to enable source map processing. If not provided, will attempt to guess based on `mode` and `devtool` in the webpack config.
+     * Set to `false` for faster builds at the expense of debuggability.
+     */
+    sourceMap?: boolean;
+    /**
+     * Instructs the plugin to alter the code of modules to maximize portability across compilations.
+     */
+    usePortableModules?: boolean;
+    /**
+     * Instructs the plugin to alter the code of async import statements to compress better and be portable across compilations.
+     */
+    compressAsyncImports?: boolean;
+}
+
+/**
+ * This is the second parameter to the NormalModuleFactory `module` hook
+ * @internal
+ */
+export declare interface _INormalModuleFactoryModuleData {
+    resourceResolveData?: {
+        /**
+         * Contents of the description file (package.json) for the module
+         */
+        descriptionFileData?: {
+            /**
+             * The name of the package
+             */
+            name: string;
+        };
+        /**
+         * Absolute path of the description file (package.json) for the module
+         */
+        descriptionFilePath?: string;
+        /**
+         * Absolute path of the directory containing the description file (package.json) for the module
+         */
+        descriptionFileRoot?: string;
+        /**
+         * Relative path from the description file (package.json) to the module
+         */
+        relativePath?: string;
+    };
+}
+
+/**
+ * Argument to the postProcessCodeFragment hook for the current execution context
+ * @public
+ */
+export declare interface IPostProcessFragmentContext {
+    /**
+     * The current webpack compilation, for error reporting
+     */
+    compilation: webpack.compilation.Compilation;
+    /**
+     * A name to use for logging
+     */
+    loggingName: string;
+    /**
+     * The current module being processed, or `undefined` if not in a module (e.g. the bootstrapper)
+     */
+    module: webpack.compilation.Module | undefined;
+}
+
+/**
+ * This is the second parameter to the thisCompilation and compilation webpack.Compiler hooks.
+ * @internal
+ */
+export declare interface _IWebpackCompilationData {
+    normalModuleFactory: webpack.compilation.NormalModuleFactory;
+}
+
+export { IWorkerPoolMinifierOptions }
+
+export { LocalMinifier }
+
+export { MessagePortMinifier }
+
+/**
+ * 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 declare 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 declare const MODULE_WRAPPER_SUFFIX: ');';
+
+/**
+ * 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 declare class ModuleMinifierPlugin implements webpack.Plugin {
+    readonly hooks: IModuleMinifierPluginHooks;
+    minifier: IModuleMinifier;
+    private readonly _enhancers;
+    private readonly _sourceMap;
+    private readonly _optionsForHash;
+    constructor(options: IModuleMinifierPluginOptions);
+    apply(compiler: webpack.Compiler): void;
+}
+
+export { NoopMinifier }
+
+/**
+ * Plugin responsible for converting the Webpack module ids (of whatever variety) to stable ids before code is handed to the minifier, then back again.
+ * Uses the node module identity of the target module. Will emit an error if it encounters multiple versions of the same package in the same compilation.
+ * @public
+ */
+export declare class PortableMinifierModuleIdsPlugin implements Plugin {
+    private readonly _minifierHooks;
+    constructor(minifierHooks: IModuleMinifierPluginHooks);
+    apply(compiler: Compiler): void;
+}
+
+/**
+ * Rehydrates an asset with minified modules.
+ * @param asset - The asset
+ * @param moduleMap - The minified modules
+ * @param banner - A banner to inject for license information
+ * @public
+ */
+export declare function rehydrateAsset(asset: IAssetInfo, moduleMap: IModuleMap, banner: string): Source;
+
+/**
+ * Stage # to use when this should be the last tap in the hook
+ * @public
+ */
+export declare const STAGE_AFTER: 100;
+
+/**
+ * Stage # to use when this should be the first tap in the hook
+ * @public
+ */
+export declare const STAGE_BEFORE: -100;
+
+export { WorkerPoolMinifier }
+
+export { }

package/lib/AsyncImportCompressionPlugin.d.ts

@@ -0,0 +1,14 @@
+import { Compiler, Plugin } from 'webpack';
+import { IModuleMinifierPluginHooks } from './ModuleMinifierPlugin.types';
+/**
+ * Plugin that replaces `Promise.all([__webpack_require__.e(1), __webpack_require__.e(12)]).then(__webpack_require__.t.bind(123,7))`
+ * with more concise expressions like `__webpack_require__.ee([1,12],123,7)`, etc.
+ *
+ * Also ensures that the code seen by the minifier does not contain chunk ids, and is therefore portable across chunks/compilations.
+ */
+export declare class AsyncImportCompressionPlugin implements Plugin {
+    private readonly _minifierHooks;
+    constructor(minifierHooks: IModuleMinifierPluginHooks);
+    apply(compiler: Compiler): void;
+}
+//# sourceMappingURL=AsyncImportCompressionPlugin.d.ts.map

package/lib/AsyncImportCompressionPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsyncImportCompressionPlugin.d.ts","sourceRoot":"","sources":["../src/AsyncImportCompressionPlugin.ts"],"names":[],"mappings":"AAGA,OAAgB,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAOpD,OAAO,EAEL,0BAA0B,EAE3B,MAAM,8BAA8B,CAAC;AA2EtC;;;;;GAKG;AACH,qBAAa,4BAA6B,YAAW,MAAM;IACzD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6B;gBAEzC,aAAa,EAAE,0BAA0B;IAIrD,KAAK,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;CAoLvC"}

package/lib/AsyncImportCompressionPlugin.js

@@ -0,0 +1,200 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncImportCompressionPlugin = void 0;
+const webpack_1 = __importDefault(require("webpack"));
+const { Template } = webpack_1.default;
+const Constants_1 = require("./Constants");
+const PLUGIN_NAME = 'AsyncImportCompressionPlugin';
+const TAP_AFTER = {
+    name: PLUGIN_NAME,
+    stage: Constants_1.STAGE_AFTER
+};
+const ASYNC_IMPORT_PREFIX = '__IMPORT_ASYNC';
+const ASYNC_IMPORT_REGEX = /__IMPORT_ASYNC[^\)]+/g;
+function getImportDependency(compilation) {
+    for (const key of compilation.dependencyTemplates.keys()) {
+        if (key.name === 'ImportDependency') {
+            return key;
+        }
+    }
+    throw new Error(`Could not find ImportDependency!`);
+}
+function getImportTypeExpression(module, originModule) {
+    var _a, _b;
+    const exportsType = (_a = module.buildMeta) === null || _a === void 0 ? void 0 : _a.exportsType;
+    const strict = (_b = originModule.buildMeta) === null || _b === void 0 ? void 0 : _b.strictHarmonyModule;
+    // Logic translated from:
+    // https://github.com/webpack/webpack/blob/3956274f1eada621e105208dcab4608883cdfdb2/lib/RuntimeTemplate.js#L110-L122
+    if (exportsType === 'namespace') {
+        // Use the raw module directly
+        return '';
+    }
+    else if (exportsType === 'named') {
+        // Create a new namespace object and forward all exports
+        return ',3';
+    }
+    else if (strict) {
+        // Synthetic default export
+        return ',1';
+    }
+    else {
+        // If modules is marked __esModule, return raw module, otherwise create a new namespace object and forward all exports
+        return ',7';
+    }
+}
+function needChunkOnDemandLoadingCode(chunk) {
+    for (const chunkGroup of chunk.groupsIterable) {
+        if (chunkGroup.getNumberOfChildren() > 0) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Plugin that replaces `Promise.all([__webpack_require__.e(1), __webpack_require__.e(12)]).then(__webpack_require__.t.bind(123,7))`
+ * with more concise expressions like `__webpack_require__.ee([1,12],123,7)`, etc.
+ *
+ * Also ensures that the code seen by the minifier does not contain chunk ids, and is therefore portable across chunks/compilations.
+ */
+class AsyncImportCompressionPlugin {
+    constructor(minifierHooks) {
+        this._minifierHooks = minifierHooks;
+    }
+    apply(compiler) {
+        const asyncImportMap = new Map();
+        const asyncImportGroups = new Map();
+        let rankedImportGroups;
+        this._minifierHooks.postProcessCodeFragment.tap({
+            name: PLUGIN_NAME,
+            stage: -1
+        }, (source, context) => {
+            const code = source.original().source();
+            let localImports;
+            ASYNC_IMPORT_REGEX.lastIndex = -1;
+            // RegExp.exec uses null or an array as the return type, explicitly
+            let match = null;
+            while ((match = ASYNC_IMPORT_REGEX.exec(code))) {
+                const token = match[0];
+                if (!localImports) {
+                    if (!context.module) {
+                        context.compilation.errors.push(new Error(`Unexpected async import ${token} in non-module context ${context.loggingName}`));
+                        return source;
+                    }
+                    localImports = asyncImportMap.get(context.module);
+                    if (!localImports) {
+                        context.compilation.errors.push(new Error(`Unexpected async import ${token} in module ${context.loggingName}`));
+                        return source;
+                    }
+                }
+                const localImport = localImports.get(token);
+                if (!localImport) {
+                    context.compilation.errors.push(new Error(`Missing metadata for ${token} in module ${context.loggingName}`));
+                    return source;
+                }
+                const { meta, module } = localImport;
+                const chunkExpression = meta.index < 0 ? JSON.stringify(meta.chunkIds) : `${meta.index}`;
+                const mapped = this._minifierHooks.finalModuleId.call(module.id, context.compilation);
+                const idExpr = mapped === undefined ? module.id : mapped;
+                // Replace with a reference or array of ideas, the target module id, and the type of import
+                source.replace(match.index, ASYNC_IMPORT_REGEX.lastIndex - 1, `${chunkExpression},${JSON.stringify(idExpr)}${getImportTypeExpression(module, context.module)}`);
+            }
+            return source;
+        });
+        compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+            asyncImportMap.clear();
+            asyncImportGroups.clear();
+            compilation.hooks.beforeChunkAssets.tap(TAP_AFTER, () => {
+                const ImportDependency = getImportDependency(compilation);
+                for (const module of compilation.modules) {
+                    const toProcess = module.modules || [module];
+                    for (const child of toProcess) {
+                        child.hasDependencies((dep) => {
+                            if (dep instanceof ImportDependency) {
+                                const { module: targetModule } = dep;
+                                let localAsyncImports = asyncImportMap.get(module);
+                                if (!localAsyncImports) {
+                                    asyncImportMap.set(module, (localAsyncImports = new Map()));
+                                }
+                                const chunkGroup = dep.block.chunkGroup;
+                                const chunkIds = chunkGroup
+                                    ? chunkGroup.chunks.map((chunk) => chunk.id).sort()
+                                    : [];
+                                const idString = chunkIds.join(';');
+                                let meta = asyncImportGroups.get(idString);
+                                if (!meta) {
+                                    asyncImportGroups.set(idString, (meta = {
+                                        chunkCount: chunkIds.length,
+                                        chunkIds: chunkIds,
+                                        count: 0,
+                                        index: -1
+                                    }));
+                                }
+                                meta.count++;
+                                const stringKey = `${targetModule.id}`.replace(/[^A-Za-z0-9_$]/g, '_');
+                                const key = `${ASYNC_IMPORT_PREFIX}${stringKey}`;
+                                localAsyncImports.set(key, {
+                                    meta,
+                                    module: targetModule
+                                });
+                            }
+                        });
+                    }
+                }
+                const rankedImports = [...asyncImportGroups]
+                    .filter((x) => x[1].count > 1)
+                    .sort((x, y) => {
+                    let diff = y[1].count - x[1].count;
+                    if (!diff) {
+                        diff = y[1].chunkCount - x[1].chunkCount;
+                    }
+                    if (!diff) {
+                        diff = x[0] > y[0] ? 1 : x[0] < y[0] ? -1 : 0;
+                    }
+                    return diff;
+                });
+                for (let i = 0, len = rankedImports.length; i < len; i++) {
+                    rankedImports[i][1].index = i;
+                    // console.log(rankedImports[i]);
+                }
+                rankedImportGroups = rankedImports.map((x) => x[1]);
+                // Have to do this after the official plugin in order to override
+                compilation.dependencyTemplates.set(ImportDependency, {
+                    apply(dep, source) {
+                        const stringKey = `${dep.module.id}`.replace(/[^A-Za-z0-9_$]/g, '_');
+                        const key = `${ASYNC_IMPORT_PREFIX}${stringKey}`;
+                        const content = `__webpack_require__.ee(${key})`;
+                        source.replace(dep.block.range[0], dep.block.range[1] - 1, content);
+                    }
+                    // Typings in webpack are incorrect. This is a DependencyTemplate object
+                });
+            });
+            compilation.mainTemplate.hooks.requireExtensions.tap(PLUGIN_NAME, (source, chunk) => {
+                if (!needChunkOnDemandLoadingCode(chunk)) {
+                    return source;
+                }
+                const { requireFn } = compilation.mainTemplate;
+                return Template.asString([
+                    `var asyncImportChunkGroups = [`,
+                    rankedImportGroups
+                        ? rankedImportGroups.map((x) => Template.indent(JSON.stringify(x.chunkIds))).join(',\n')
+                        : '',
+                    `];`,
+                    `${requireFn}.ee = function (groupOrId, moduleId, importType) {`,
+                    Template.indent([
+                        `return Promise.all((Array.isArray(groupOrId) ? groupOrId : asyncImportChunkGroups[groupOrId]).map(function (x) { return ${requireFn}.e(x); }))`,
+                        `.then(importType ? ${requireFn}.t.bind(0,moduleId,importType) : ${requireFn}.bind(0,moduleId));`
+                    ]),
+                    `};`,
+                    source
+                ]);
+            });
+        });
+    }
+}
+exports.AsyncImportCompressionPlugin = AsyncImportCompressionPlugin;
+//# sourceMappingURL=AsyncImportCompressionPlugin.js.map