xhs-mp-pack 1.1.0-beta.0

package/dist/plugins/ProgressPlugin.js

@@ -0,0 +1,494 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Compiler_1 = __importDefault(require("@/Compiler"));
+const MultiCompiler_1 = __importDefault(require("@/MultiCompiler"));
+const NormalModule_1 = __importDefault(require("@/module/NormalModule"));
+const identifier_1 = require("@/base/identifier");
+const median3 = (a, b, c) => a + b + c - Math.max(a, b, c) - Math.min(a, b, c);
+const createDefaultHandler = (profile, logger) => {
+    const lastStateInfo = [];
+    const defaultHandler = (percentage, msg, ...args) => {
+        if (profile) {
+            if (percentage === 0) {
+                lastStateInfo.length = 0;
+            }
+            const fullState = [msg, ...args];
+            const state = fullState.map(s => s.replace(/\d+\/\d+ /g, ''));
+            const now = Date.now();
+            const len = Math.max(state.length, lastStateInfo.length);
+            for (let i = len; i >= 0; i--) {
+                const stateItem = i < state.length ? state[i] : undefined;
+                const lastStateItem = i < lastStateInfo.length ? lastStateInfo[i] : undefined;
+                if (lastStateItem) {
+                    if (stateItem !== lastStateItem.value) {
+                        const diff = now - lastStateItem.time;
+                        if (lastStateItem.value) {
+                            let reportState = lastStateItem.value;
+                            if (i > 0) {
+                                reportState = `${lastStateInfo[i - 1].value} > ${reportState}`;
+                            }
+                            const stateMsg = `${' | '.repeat(i)}${diff} ms ${reportState}`;
+                            const d = diff;
+                            // This depends on timing so we ignore it for coverage
+                            /* istanbul ignore next */
+                            // eslint-disable-next-line no-lone-blocks
+                            {
+                                if (d > 10000) {
+                                    logger.error(stateMsg);
+                                }
+                                else if (d > 1000) {
+                                    logger.warn(stateMsg);
+                                }
+                                else if (d > 10) {
+                                    logger.info(stateMsg);
+                                }
+                                else if (d > 5) {
+                                    logger.log(stateMsg);
+                                }
+                                else {
+                                    logger.debug(stateMsg);
+                                }
+                            }
+                        }
+                        if (stateItem === undefined) {
+                            lastStateInfo.length = i;
+                        }
+                        else {
+                            lastStateItem.value = stateItem;
+                            lastStateItem.time = now;
+                            lastStateInfo.length = i + 1;
+                        }
+                    }
+                }
+                else {
+                    lastStateInfo[i] = {
+                        value: stateItem,
+                        time: now,
+                    };
+                }
+            }
+        }
+        logger.status(`${Math.floor(percentage * 100)}%`, msg, ...args);
+        if (percentage === 1 || (!msg && args.length === 0))
+            logger.status();
+    };
+    return defaultHandler;
+};
+const progressReporters = new WeakMap();
+class ProgressPlugin {
+    static getReporter(compiler) {
+        return progressReporters.get(compiler);
+    }
+    constructor(options = {}) {
+        this.invalid = false;
+        if (typeof options === 'function') {
+            options = {
+                handler: options,
+            };
+        }
+        options = Object.assign(Object.assign({}, ProgressPlugin.defaultOptions), options);
+        this.profile = options.profile;
+        this.handler = options.handler;
+        this.modulesCount = options.modulesCount;
+        this.dependenciesCount = options.dependenciesCount;
+        this.showEntries = options.entries;
+        this.showModules = options.modules;
+        this.showDependencies = options.dependencies;
+        this.showActiveModules = options.activeModules;
+        this.percentBy = options.percentBy;
+    }
+    apply(compiler) {
+        const handler = this.handler ||
+            createDefaultHandler(this.profile, compiler.getInfrastructureLogger('webpack.Progress'));
+        if (compiler instanceof MultiCompiler_1.default) {
+            this._applyOnMultiCompiler(compiler, handler);
+        }
+        else if (compiler instanceof Compiler_1.default) {
+            this._applyOnCompiler(compiler, handler);
+        }
+    }
+    _applyOnMultiCompiler(compiler, handler) {
+        let states = compiler.compilers.map(() => [0]);
+        compiler.compilers.forEach((compiler, idx) => {
+            new ProgressPlugin((p, msg, ...args) => {
+                if (this.invalid) {
+                    return;
+                }
+                states[idx] = [p, msg, ...args];
+                let sum = 0;
+                for (const [p] of states)
+                    sum += p;
+                const procentage = sum / states.length;
+                if (procentage >= 1) {
+                    states = states.map(() => [0]);
+                }
+                handler(procentage, `[${idx}] ${msg}`, ...args);
+            }).apply(compiler);
+            compiler.cache.hooks.shutdown.tap({ name: 'ProgressPlugin', stage: -100 }, () => {
+                this.invalid = true;
+            });
+        });
+    }
+    _applyOnCompiler(compiler, handler) {
+        const showEntries = this.showEntries;
+        const showModules = this.showModules;
+        const showDependencies = this.showDependencies;
+        const showActiveModules = this.showActiveModules;
+        let lastActiveModule = '';
+        let currentLoader = '';
+        let lastModulesCount = 0;
+        let lastDependenciesCount = 0;
+        let lastEntriesCount = 0;
+        let modulesCount = 0;
+        let dependenciesCount = 0;
+        let entriesCount = 1;
+        let doneModules = 0;
+        let doneDependencies = 0;
+        let doneEntries = 0;
+        const activeModules = new Set();
+        let lastUpdate = 0;
+        const updateThrottled = () => {
+            if (lastUpdate + 500 < Date.now())
+                update();
+        };
+        const update = () => {
+            const items = [];
+            const percentByModules = doneModules / Math.max(lastModulesCount || this.modulesCount || 1, modulesCount);
+            const percentByEntries = doneEntries / Math.max(lastEntriesCount || this.dependenciesCount || 1, entriesCount);
+            const percentByDependencies = doneDependencies / Math.max(lastDependenciesCount || 1, dependenciesCount);
+            let percentageFactor;
+            switch (this.percentBy) {
+                case 'entries':
+                    percentageFactor = percentByEntries;
+                    break;
+                case 'dependencies':
+                    percentageFactor = percentByDependencies;
+                    break;
+                case 'modules':
+                    percentageFactor = percentByModules;
+                    break;
+                default:
+                    percentageFactor = median3(percentByModules, percentByEntries, percentByDependencies);
+            }
+            const percentage = 0.1 + percentageFactor * 0.55;
+            if (currentLoader) {
+                items.push(`import loader ${(0, identifier_1.contextify)(compiler.context, currentLoader, compiler.root)}`);
+            }
+            else {
+                const statItems = [];
+                if (showEntries) {
+                    statItems.push(`${doneEntries}/${entriesCount} entries`);
+                }
+                if (showDependencies) {
+                    statItems.push(`${doneDependencies}/${dependenciesCount} dependencies`);
+                }
+                if (showModules) {
+                    statItems.push(`${doneModules}/${modulesCount} modules`);
+                }
+                if (showActiveModules) {
+                    statItems.push(`${activeModules.size} active`);
+                }
+                if (statItems.length > 0) {
+                    items.push(statItems.join(' '));
+                }
+                if (showActiveModules) {
+                    items.push(lastActiveModule);
+                }
+            }
+            handler(percentage, 'building', ...items);
+            lastUpdate = Date.now();
+        };
+        const factorizeAdd = () => {
+            dependenciesCount++;
+            if (dependenciesCount < 50 || dependenciesCount % 100 === 0)
+                updateThrottled();
+        };
+        const factorizeDone = () => {
+            doneDependencies++;
+            if (doneDependencies < 50 || doneDependencies % 100 === 0)
+                updateThrottled();
+        };
+        const moduleAdd = () => {
+            modulesCount++;
+            if (modulesCount < 50 || modulesCount % 100 === 0)
+                updateThrottled();
+        };
+        const moduleBuild = module => {
+            const ident = module.identifier();
+            if (ident) {
+                activeModules.add(ident);
+                lastActiveModule = ident;
+                update();
+            }
+        };
+        const entryAdd = (entry, options) => {
+            entriesCount++;
+            if (entriesCount < 5 || entriesCount % 10 === 0)
+                updateThrottled();
+        };
+        const moduleDone = module => {
+            doneModules++;
+            if (showActiveModules) {
+                const ident = module.identifier();
+                if (ident) {
+                    activeModules.delete(ident);
+                    if (lastActiveModule === ident) {
+                        lastActiveModule = '';
+                        for (const m of activeModules) {
+                            lastActiveModule = m;
+                        }
+                        update();
+                        return;
+                    }
+                }
+            }
+            if (doneModules < 50 || doneModules % 100 === 0)
+                updateThrottled();
+        };
+        const entryDone = (entry, options) => {
+            doneEntries++;
+            update();
+        };
+        const cache = compiler.getCache('ProgressPlugin').getItemCache('counts', null);
+        let cacheGetPromise;
+        compiler.hooks.beforeCompile.tap('ProgressPlugin', () => {
+            if (!cacheGetPromise) {
+                cacheGetPromise = cache.getPromise().then(data => {
+                    if (data) {
+                        lastModulesCount = lastModulesCount || data.modulesCount;
+                        lastDependenciesCount = lastDependenciesCount || data.dependenciesCount;
+                    }
+                    return data;
+                }, err => {
+                    // Ignore error
+                });
+            }
+        });
+        compiler.hooks.afterCompile.tapPromise('ProgressPlugin', compilation => {
+            if (compilation.compiler.isChild())
+                return Promise.resolve();
+            return cacheGetPromise.then((oldData) => __awaiter(this, void 0, void 0, function* () {
+                if (!oldData ||
+                    oldData.modulesCount !== modulesCount ||
+                    oldData.dependenciesCount !== dependenciesCount) {
+                    yield cache.storePromise({ modulesCount, dependenciesCount });
+                }
+            }));
+        });
+        compiler.hooks.compilation.tap('ProgressPlugin', compilation => {
+            if (compilation.compiler.isChild())
+                return;
+            lastModulesCount = modulesCount;
+            lastEntriesCount = entriesCount;
+            lastDependenciesCount = dependenciesCount;
+            modulesCount = dependenciesCount = entriesCount = 0;
+            doneModules = doneDependencies = doneEntries = 0;
+            compilation.factorizeQueue.hooks.added.tap('ProgressPlugin', factorizeAdd);
+            compilation.factorizeQueue.hooks.result.tap('ProgressPlugin', factorizeDone);
+            compilation.addModuleQueue.hooks.added.tap('ProgressPlugin', moduleAdd);
+            compilation.processDependenciesQueue.hooks.result.tap('ProgressPlugin', moduleDone);
+            if (showActiveModules) {
+                compilation.hooks.buildModule.tap('ProgressPlugin', moduleBuild);
+            }
+            compilation.hooks.addEntry.tap('ProgressPlugin', entryAdd);
+            compilation.hooks.failedEntry.tap('ProgressPlugin', entryDone);
+            compilation.hooks.succeedEntry.tap('ProgressPlugin', entryDone);
+            // avoid dynamic require if bundled with webpack
+            // @ts-expect-error
+            // eslint-disable-next-line camelcase
+            if (typeof __webpack_require__ !== 'function') {
+                const requiredLoaders = new Set();
+                NormalModule_1.default.getCompilationHooks(compilation).beforeLoaders.tap('ProgressPlugin', loaders => {
+                    for (const loader of loaders) {
+                        if (loader.type !== 'module' && !requiredLoaders.has(loader.loader)) {
+                            requiredLoaders.add(loader.loader);
+                            currentLoader = loader.loader;
+                            update();
+                            require(loader.loader);
+                        }
+                    }
+                    if (currentLoader) {
+                        currentLoader = '';
+                        update();
+                    }
+                });
+            }
+            const hooks = {
+                finishModules: 'finish module graph',
+                seal: 'plugins',
+                optimizeDependencies: 'dependencies optimization',
+                afterOptimizeDependencies: 'after dependencies optimization',
+                beforeChunks: 'chunk graph',
+                afterChunks: 'after chunk graph',
+                optimize: 'optimizing',
+                optimizeModules: 'module optimization',
+                afterOptimizeModules: 'after module optimization',
+                optimizeChunks: 'chunk optimization',
+                afterOptimizeChunks: 'after chunk optimization',
+                optimizeTree: 'module and chunk tree optimization',
+                afterOptimizeTree: 'after module and chunk tree optimization',
+                optimizeChunkModules: 'chunk modules optimization',
+                afterOptimizeChunkModules: 'after chunk modules optimization',
+                reviveModules: 'module reviving',
+                beforeModuleIds: 'before module ids',
+                moduleIds: 'module ids',
+                optimizeModuleIds: 'module id optimization',
+                afterOptimizeModuleIds: 'module id optimization',
+                reviveChunks: 'chunk reviving',
+                beforeChunkIds: 'before chunk ids',
+                chunkIds: 'chunk ids',
+                optimizeChunkIds: 'chunk id optimization',
+                afterOptimizeChunkIds: 'after chunk id optimization',
+                recordModules: 'record modules',
+                recordChunks: 'record chunks',
+                beforeModuleHash: 'module hashing',
+                beforeCodeGeneration: 'code generation',
+                beforeRuntimeRequirements: 'runtime requirements',
+                beforeHash: 'hashing',
+                afterHash: 'after hashing',
+                recordHash: 'record hash',
+                beforeModuleAssets: 'module assets processing',
+                beforeChunkAssets: 'chunk assets processing',
+                processAssets: 'asset processing',
+                afterProcessAssets: 'after asset optimization',
+                record: 'recording',
+                afterSeal: 'after seal',
+            };
+            const numberOfHooks = Object.keys(hooks).length;
+            Object.keys(hooks).forEach((name, idx) => {
+                const title = hooks[name];
+                const percentage = (idx / numberOfHooks) * 0.25 + 0.7;
+                compilation.hooks[name].intercept({
+                    name: 'ProgressPlugin',
+                    call() {
+                        handler(percentage, 'sealing', title);
+                    },
+                    done() {
+                        progressReporters.set(compiler, undefined);
+                        handler(percentage, 'sealing', title);
+                    },
+                    result() {
+                        handler(percentage, 'sealing', title);
+                    },
+                    error() {
+                        handler(percentage, 'sealing', title);
+                    },
+                    tap(tap) {
+                        // p is percentage from 0 to 1
+                        // args is any number of messages in a hierarchical matter
+                        // @ts-ignore
+                        progressReporters.set(compilation.compiler, (p, ...args) => {
+                            handler(percentage, 'sealing', title, tap.name, ...args);
+                        });
+                        handler(percentage, 'sealing', title, tap.name);
+                    },
+                });
+            });
+        });
+        compiler.hooks.make.intercept({
+            name: 'ProgressPlugin',
+            call() {
+                handler(0.1, 'building');
+            },
+            done() {
+                handler(0.65, 'building');
+            },
+        });
+        const interceptHook = (hook, progress, category, name) => {
+            hook.intercept({
+                name: 'ProgressPlugin',
+                call() {
+                    handler(progress, category, name);
+                },
+                done() {
+                    progressReporters.set(compiler, undefined);
+                    handler(progress, category, name);
+                },
+                result() {
+                    handler(progress, category, name);
+                },
+                error() {
+                    handler(progress, category, name);
+                },
+                tap(tap) {
+                    // @ts-ignore
+                    progressReporters.set(compiler, (p, ...args) => {
+                        handler(progress, category, name, tap.name, ...args);
+                    });
+                    handler(progress, category, name, tap.name);
+                },
+            });
+        };
+        compiler.cache.hooks.endIdle.intercept({
+            name: 'ProgressPlugin',
+            call() {
+                handler(0, '');
+            },
+        });
+        interceptHook(compiler.cache.hooks.endIdle, 0.01, 'cache', 'end idle');
+        compiler.hooks.beforeRun.intercept({
+            name: 'ProgressPlugin',
+            call() {
+                handler(0, '');
+            },
+        });
+        interceptHook(compiler.hooks.beforeRun, 0.01, 'setup', 'before run');
+        interceptHook(compiler.hooks.run, 0.02, 'setup', 'run');
+        interceptHook(compiler.hooks.watchRun, 0.03, 'setup', 'watch run');
+        interceptHook(compiler.hooks.normalModuleFactory, 0.04, 'setup', 'normal module factory');
+        interceptHook(compiler.hooks.contextModuleFactory, 0.05, 'setup', 'context module factory');
+        interceptHook(compiler.hooks.beforeCompile, 0.06, 'setup', 'before compile');
+        interceptHook(compiler.hooks.compile, 0.07, 'setup', 'compile');
+        interceptHook(compiler.hooks.thisCompilation, 0.08, 'setup', 'compilation');
+        interceptHook(compiler.hooks.compilation, 0.09, 'setup', 'compilation');
+        interceptHook(compiler.hooks.finishMake, 0.69, 'building', 'finish');
+        interceptHook(compiler.hooks.emit, 0.95, 'emitting', 'emit');
+        interceptHook(compiler.hooks.afterEmit, 0.98, 'emitting', 'after emit');
+        interceptHook(compiler.hooks.done, 0.99, 'done', 'plugins');
+        compiler.hooks.done.intercept({
+            name: 'ProgressPlugin',
+            done() {
+                handler(0.99, '');
+            },
+        });
+        interceptHook(compiler.cache.hooks.storeBuildDependencies, 0.99, 'cache', 'store build dependencies');
+        interceptHook(compiler.cache.hooks.shutdown, 0.99, 'cache', 'shutdown');
+        interceptHook(compiler.cache.hooks.beginIdle, 0.99, 'cache', 'begin idle');
+        interceptHook(compiler.hooks.watchClose, 0.99, 'end', 'closing watch compilation');
+        compiler.cache.hooks.beginIdle.intercept({
+            name: 'ProgressPlugin',
+            done() {
+                handler(1, '');
+            },
+        });
+        compiler.cache.hooks.shutdown.intercept({
+            name: 'ProgressPlugin',
+            done() {
+                handler(1, '');
+            },
+        });
+    }
+}
+ProgressPlugin.defaultOptions = {
+    profile: false,
+    modulesCount: 5000,
+    dependenciesCount: 10000,
+    modules: true,
+    dependencies: true,
+    activeModules: false,
+    entries: true,
+};
+ProgressPlugin.createDefaultHandler = createDefaultHandler;
+exports.default = ProgressPlugin;

package/dist/plugins/RecordIdsPlugin.d.ts

@@ -0,0 +1,9 @@
+interface IOptions {
+    portableIds?: boolean;
+}
+declare class RecordIdsPlugin {
+    options: IOptions;
+    constructor(options?: IOptions);
+    apply(compiler: any): void;
+}
+export default RecordIdsPlugin;

package/dist/plugins/RecordIdsPlugin.js

@@ -0,0 +1,175 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const comparators_1 = require("@/base/comparators");
+const identifierUtils = __importStar(require("@/base/identifier"));
+class RecordIdsPlugin {
+    constructor(options) {
+        this.options = options || {};
+    }
+    apply(compiler) {
+        const portableIds = this.options.portableIds;
+        const makePathsRelative = identifierUtils.makePathsRelative.bindContextCache(compiler.context, compiler.root);
+        const getModuleIdentifier = module => {
+            if (portableIds) {
+                return makePathsRelative(module.identifier());
+            }
+            return module.identifier();
+        };
+        compiler.hooks.compilation.tap('RecordIdsPlugin', compilation => {
+            compilation.hooks.recordModules.tap('RecordIdsPlugin', (modules, records) => {
+                const chunkGraph = compilation.chunkGraph;
+                if (!records.modules)
+                    records.modules = {};
+                if (!records.modules.byIdentifier)
+                    records.modules.byIdentifier = {};
+                const usedIds = new Set();
+                for (const module of modules) {
+                    const moduleId = chunkGraph.getModuleId(module);
+                    if (typeof moduleId !== 'number')
+                        continue;
+                    const identifier = getModuleIdentifier(module);
+                    records.modules.byIdentifier[identifier] = moduleId;
+                    usedIds.add(moduleId);
+                }
+                records.modules.usedIds = Array.from(usedIds).sort(comparators_1.compareNumbers);
+            });
+            compilation.hooks.reviveModules.tap('RecordIdsPlugin', (modules, records) => {
+                if (!records.modules)
+                    return;
+                if (records.modules.byIdentifier) {
+                    const chunkGraph = compilation.chunkGraph;
+                    const usedIds = new Set();
+                    for (const module of modules) {
+                        const moduleId = chunkGraph.getModuleId(module);
+                        if (moduleId !== null)
+                            continue;
+                        const identifier = getModuleIdentifier(module);
+                        const id = records.modules.byIdentifier[identifier];
+                        if (id === undefined)
+                            continue;
+                        if (usedIds.has(id))
+                            continue;
+                        usedIds.add(id);
+                        chunkGraph.setModuleId(module, id);
+                    }
+                }
+                if (Array.isArray(records.modules.usedIds)) {
+                    compilation.usedModuleIds = new Set(records.modules.usedIds);
+                }
+            });
+            const getChunkSources = chunk => {
+                const sources = [];
+                for (const chunkGroup of chunk.groupsIterable) {
+                    const index = chunkGroup.chunks.indexOf(chunk);
+                    if (chunkGroup.name) {
+                        sources.push(`${index} ${chunkGroup.name}`);
+                    }
+                    else {
+                        for (const origin of chunkGroup.origins) {
+                            if (origin.module) {
+                                if (origin.request) {
+                                    sources.push(`${index} ${getModuleIdentifier(origin.module)} ${origin.request}`);
+                                }
+                                else if (typeof origin.loc === 'string') {
+                                    sources.push(`${index} ${getModuleIdentifier(origin.module)} ${origin.loc}`);
+                                }
+                                else if (origin.loc && typeof origin.loc === 'object' && 'start' in origin.loc) {
+                                    sources.push(`${index} ${getModuleIdentifier(origin.module)} ${JSON.stringify(origin.loc.start)}`);
+                                }
+                            }
+                        }
+                    }
+                }
+                return sources;
+            };
+            compilation.hooks.recordChunks.tap('RecordIdsPlugin', (chunks, records) => {
+                if (!records.chunks)
+                    records.chunks = {};
+                if (!records.chunks.byName)
+                    records.chunks.byName = {};
+                if (!records.chunks.bySource)
+                    records.chunks.bySource = {};
+                const usedIds = new Set();
+                for (const chunk of chunks) {
+                    if (typeof chunk.id !== 'number')
+                        continue;
+                    const name = chunk.name;
+                    if (name)
+                        records.chunks.byName[name] = chunk.id;
+                    const sources = getChunkSources(chunk);
+                    for (const source of sources) {
+                        records.chunks.bySource[source] = chunk.id;
+                    }
+                    usedIds.add(chunk.id);
+                }
+                records.chunks.usedIds = Array.from(usedIds).sort(comparators_1.compareNumbers);
+            });
+            compilation.hooks.reviveChunks.tap('RecordIdsPlugin', (chunks, records) => {
+                if (!records.chunks)
+                    return;
+                const usedIds = new Set();
+                if (records.chunks.byName) {
+                    for (const chunk of chunks) {
+                        if (chunk.id !== null)
+                            continue;
+                        if (!chunk.name)
+                            continue;
+                        const id = records.chunks.byName[chunk.name];
+                        if (id === undefined)
+                            continue;
+                        if (usedIds.has(id))
+                            continue;
+                        usedIds.add(id);
+                        chunk.id = id;
+                        chunk.ids = [id];
+                    }
+                }
+                if (records.chunks.bySource) {
+                    for (const chunk of chunks) {
+                        if (chunk.id !== null)
+                            continue;
+                        const sources = getChunkSources(chunk);
+                        for (const source of sources) {
+                            const id = records.chunks.bySource[source];
+                            if (id === undefined)
+                                continue;
+                            if (usedIds.has(id))
+                                continue;
+                            usedIds.add(id);
+                            chunk.id = id;
+                            chunk.ids = [id];
+                            break;
+                        }
+                    }
+                }
+                if (Array.isArray(records.chunks.usedIds)) {
+                    compilation.usedChunkIds = new Set(records.chunks.usedIds);
+                }
+            });
+        });
+    }
+}
+exports.default = RecordIdsPlugin;

package/dist/plugins/UseStrictPlugin.d.ts

@@ -0,0 +1,4 @@
+declare class UseStrictPlugin {
+    apply(compiler: any): void;
+}
+export default UseStrictPlugin;