xhs-mp-pack 1.1.0-beta.0

package/dist/plugins/optimize/EnsureChunkConditionsPlugin.d.ts

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

package/dist/plugins/optimize/EnsureChunkConditionsPlugin.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const OptimizationStages_1 = require("@/plugins/optimize/OptimizationStages");
+class EnsureChunkConditionsPlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap('EnsureChunkConditionsPlugin', compilation => {
+            const handler = chunks => {
+                const chunkGraph = compilation.chunkGraph;
+                // These sets are hoisted here to save memory
+                // They are cleared at the end of every loop
+                const sourceChunks = new Set();
+                const chunkGroups = new Set();
+                for (const module of compilation.modules) {
+                    if (!module.hasChunkCondition())
+                        continue;
+                    for (const chunk of chunkGraph.getModuleChunksIterable(module)) {
+                        if (!module.chunkCondition(chunk, compilation)) {
+                            sourceChunks.add(chunk);
+                            for (const group of chunk.groupsIterable) {
+                                chunkGroups.add(group);
+                            }
+                        }
+                    }
+                    if (sourceChunks.size === 0)
+                        continue;
+                    const targetChunks = new Set();
+                    chunkGroupLoop: for (const chunkGroup of chunkGroups) {
+                        // Can module be placed in a chunk of this group?
+                        for (const chunk of chunkGroup.chunks) {
+                            if (module.chunkCondition(chunk, compilation)) {
+                                targetChunks.add(chunk);
+                                continue chunkGroupLoop;
+                            }
+                        }
+                        // We reached the entrypoint: fail
+                        if (chunkGroup.isInitial()) {
+                            throw new Error(`Cannot fullfil chunk condition of ${module.identifier()}`);
+                        }
+                        // Try placing in all parents
+                        for (const group of chunkGroup.parentsIterable) {
+                            chunkGroups.add(group);
+                        }
+                    }
+                    for (const sourceChunk of sourceChunks) {
+                        chunkGraph.disconnectChunkAndModule(sourceChunk, module);
+                    }
+                    for (const targetChunk of targetChunks) {
+                        chunkGraph.connectChunkAndModule(targetChunk, module);
+                    }
+                    sourceChunks.clear();
+                    chunkGroups.clear();
+                }
+            };
+            compilation.hooks.optimizeChunks.tap({
+                name: 'EnsureChunkConditionsPlugin',
+                stage: OptimizationStages_1.STAGE_BASIC,
+            }, handler);
+        });
+    }
+}
+exports.default = EnsureChunkConditionsPlugin;

package/dist/plugins/optimize/FlagAllModulesAsUsedPlugin.d.ts

@@ -0,0 +1,6 @@
+declare class FlagAllModulesAsUsedPlugin {
+    explanation: string;
+    constructor(explanation: string);
+    apply(compiler: any): void;
+}
+export default FlagAllModulesAsUsedPlugin;

package/dist/plugins/optimize/FlagAllModulesAsUsedPlugin.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const RuntimeHelpers_1 = require("@/module/RuntimeHelpers");
+const PLUGIN_NAME = 'FlagAllModulesAsUsedPlugin';
+class FlagAllModulesAsUsedPlugin {
+    constructor(explanation) {
+        this.explanation = explanation;
+    }
+    apply(compiler) {
+        compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
+            const moduleGraph = compilation.moduleGraph;
+            compilation.hooks.optimizeDependencies.tap(PLUGIN_NAME, modules => {
+                let runtime;
+                for (const [name, { options }] of compilation.entries) {
+                    runtime = (0, RuntimeHelpers_1.mergeRuntimeOwned)(runtime, (0, RuntimeHelpers_1.getEntryRuntime)(compilation, name, options));
+                }
+                for (const module of modules) {
+                    const exportsInfo = moduleGraph.getExportsInfo(module);
+                    exportsInfo.setUsedInUnknownWay(runtime);
+                    moduleGraph.addExtraReason(module, this.explanation);
+                    if (module.factoryMeta === undefined) {
+                        module.factoryMeta = {};
+                    }
+                    module.factoryMeta.sideEffectFree = false;
+                }
+            });
+        });
+    }
+}
+exports.default = FlagAllModulesAsUsedPlugin;

package/dist/plugins/optimize/FlagDependencyExportsPlugin.d.ts

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

package/dist/plugins/optimize/FlagDependencyExportsPlugin.js

@@ -0,0 +1,275 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const neo_async_1 = __importDefault(require("neo-async"));
+const Queue_1 = __importDefault(require("@/base/Queue"));
+const PLUGIN_NAME = 'FlagDependencyExportsPlugin';
+const PLUGIN_LOGGER_NAME = `webpack.${PLUGIN_NAME}`;
+class FlagDependencyExportsPlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
+            const moduleGraph = compilation.moduleGraph;
+            const cache = compilation.getCache(PLUGIN_NAME);
+            compilation.hooks.finishModules.tapAsync(PLUGIN_NAME, (modules, callback) => {
+                const logger = compilation.getLogger(PLUGIN_LOGGER_NAME);
+                let statRestoredFromMemCache = 0;
+                let statRestoredFromCache = 0;
+                let statNoExports = 0;
+                let statFlaggedUncached = 0;
+                let statNotCached = 0;
+                let statQueueItemsProcessed = 0;
+                const { moduleMemCaches } = compilation;
+                const queue = new Queue_1.default();
+                // Step 1: Try to restore cached provided export info from cache
+                logger.time('restore cached provided exports');
+                neo_async_1.default.each(modules, (module, callback) => {
+                    const exportsInfo = moduleGraph.getExportsInfo(module);
+                    // If the module doesn't have an exportsType, it's a module
+                    // without declared exoorts
+                    if (!module.buildMeta || !module.buildMeta.exportsType) {
+                        if (exportsInfo.otherExportsInfo.provided !== null) {
+                            // It's a module without declared exports
+                            statNoExports++;
+                            exportsInfo.setHasProvideInfo();
+                            exportsInfo.setUnknownExportsProvided();
+                            return callback();
+                        }
+                    }
+                    // If the module has no hash, it's uncacheable
+                    if (typeof module.buildInfo.hash !== 'string') {
+                        statFlaggedUncached++;
+                        // Enqueue uncacheable module for determining the exports
+                        queue.enqueue(module);
+                        exportsInfo.setHasProvideInfo();
+                        return callback();
+                    }
+                    const memCache = moduleMemCaches === null || moduleMemCaches === void 0 ? void 0 : moduleMemCaches.get(module);
+                    const memCacheValue = memCache === null || memCache === void 0 ? void 0 : memCache.get(this);
+                    if (memCacheValue !== undefined) {
+                        statRestoredFromMemCache++;
+                        exportsInfo.restoreProvided(memCacheValue);
+                        return callback();
+                    }
+                    cache.get(module.identifier(), module.buildInfo.hash, (err, result) => {
+                        if (err)
+                            return callback(err);
+                        if (result !== undefined) {
+                            statRestoredFromCache++;
+                            exportsInfo.restoreProvided(result);
+                        }
+                        else {
+                            statNotCached++;
+                            // Without cached info enqueue module for determining the exports
+                            queue.enqueue(module);
+                            exportsInfo.setHasProvideInfo();
+                        }
+                        callback();
+                    });
+                }, err => {
+                    logger.timeEnd('restore cached provided exports');
+                    if (err)
+                        return callback(err);
+                    const modulesToStore = new Set();
+                    const dependencies = new Map();
+                    let module;
+                    let exportsInfo;
+                    const exportsSpecsFromDependencies = new Map();
+                    let cacheable = true;
+                    let changed = false;
+                    const processDependenciesBlock = depBlock => {
+                        for (const dep of depBlock.dependencies) {
+                            processDependency(dep);
+                        }
+                        for (const block of depBlock.blocks) {
+                            processDependenciesBlock(block);
+                        }
+                    };
+                    const processDependency = dep => {
+                        const exportDesc = dep.getExports(moduleGraph);
+                        if (!exportDesc)
+                            return;
+                        exportsSpecsFromDependencies.set(dep, exportDesc);
+                    };
+                    const processExportsSpec = (dep, exportDesc) => {
+                        const exports = exportDesc.exports;
+                        const globalCanMangle = exportDesc.canMangle;
+                        const globalFrom = exportDesc.from;
+                        const globalPriority = exportDesc.priority;
+                        const globalTerminalBinding = exportDesc.terminalBinding || false;
+                        const exportDeps = exportDesc.dependencies;
+                        if (exportDesc.hideExports) {
+                            for (const name of exportDesc.hideExports) {
+                                const exportInfo = exportsInfo.getExportInfo(name);
+                                exportInfo.unsetTarget(dep);
+                            }
+                        }
+                        if (exports === true) {
+                            // unknown exports
+                            if (exportsInfo.setUnknownExportsProvided(globalCanMangle, exportDesc.excludeExports, globalFrom && dep, globalFrom, globalPriority)) {
+                                changed = true;
+                            }
+                        }
+                        else if (Array.isArray(exports)) {
+                            const mergeExports = (exportsInfo, exports) => {
+                                for (const exportNameOrSpec of exports) {
+                                    let name;
+                                    let canMangle = globalCanMangle;
+                                    let terminalBinding = globalTerminalBinding;
+                                    let exports;
+                                    let from = globalFrom;
+                                    let fromExport;
+                                    let priority = globalPriority;
+                                    let hidden = false;
+                                    if (typeof exportNameOrSpec === 'string') {
+                                        name = exportNameOrSpec;
+                                    }
+                                    else {
+                                        name = exportNameOrSpec.name;
+                                        if (exportNameOrSpec.canMangle !== undefined)
+                                            canMangle = exportNameOrSpec.canMangle;
+                                        if (exportNameOrSpec.export !== undefined)
+                                            fromExport = exportNameOrSpec.export;
+                                        if (exportNameOrSpec.exports !== undefined)
+                                            exports = exportNameOrSpec.exports;
+                                        if (exportNameOrSpec.from !== undefined)
+                                            from = exportNameOrSpec.from;
+                                        if (exportNameOrSpec.priority !== undefined)
+                                            priority = exportNameOrSpec.priority;
+                                        if (exportNameOrSpec.terminalBinding !== undefined)
+                                            terminalBinding = exportNameOrSpec.terminalBinding;
+                                        if (exportNameOrSpec.hidden !== undefined)
+                                            hidden = exportNameOrSpec.hidden;
+                                    }
+                                    const exportInfo = exportsInfo.getExportInfo(name);
+                                    if (exportInfo.provided === false || exportInfo.provided === null) {
+                                        exportInfo.provided = true;
+                                        changed = true;
+                                    }
+                                    if (exportInfo.canMangleProvide !== false && canMangle === false) {
+                                        exportInfo.canMangleProvide = false;
+                                        changed = true;
+                                    }
+                                    if (terminalBinding && !exportInfo.terminalBinding) {
+                                        exportInfo.terminalBinding = true;
+                                        changed = true;
+                                    }
+                                    if (exports) {
+                                        const nestedExportsInfo = exportInfo.createNestedExportsInfo();
+                                        mergeExports(nestedExportsInfo, exports);
+                                    }
+                                    if (from &&
+                                        (hidden
+                                            ? exportInfo.unsetTarget(dep)
+                                            : exportInfo.setTarget(dep, from, fromExport === undefined ? [name] : fromExport, priority))) {
+                                        changed = true;
+                                    }
+                                    // Recalculate target exportsInfo
+                                    const target = exportInfo.getTarget(moduleGraph);
+                                    let targetExportsInfo;
+                                    if (target) {
+                                        const targetModuleExportsInfo = moduleGraph.getExportsInfo(target.module);
+                                        targetExportsInfo = targetModuleExportsInfo.getNestedExportsInfo(target.export);
+                                        // add dependency for this module
+                                        const set = dependencies.get(target.module);
+                                        if (set === undefined) {
+                                            dependencies.set(target.module, new Set([module]));
+                                        }
+                                        else {
+                                            set.add(module);
+                                        }
+                                    }
+                                    if (exportInfo.exportsInfoOwned) {
+                                        if (exportInfo.exportsInfo.setRedirectNamedTo(targetExportsInfo)) {
+                                            changed = true;
+                                        }
+                                    }
+                                    else if (exportInfo.exportsInfo !== targetExportsInfo) {
+                                        exportInfo.exportsInfo = targetExportsInfo;
+                                        changed = true;
+                                    }
+                                }
+                            };
+                            mergeExports(exportsInfo, exports);
+                        }
+                        // store dependencies
+                        if (exportDeps) {
+                            cacheable = false;
+                            for (const exportDependency of exportDeps) {
+                                // add dependency for this module
+                                const set = dependencies.get(exportDependency);
+                                if (set === undefined) {
+                                    dependencies.set(exportDependency, new Set([module]));
+                                }
+                                else {
+                                    set.add(module);
+                                }
+                            }
+                        }
+                    };
+                    const notifyDependencies = () => {
+                        const deps = dependencies.get(module);
+                        if (deps !== undefined) {
+                            for (const dep of deps) {
+                                queue.enqueue(dep);
+                            }
+                        }
+                    };
+                    logger.time('figure out provided exports');
+                    while (queue.length > 0) {
+                        module = queue.dequeue();
+                        statQueueItemsProcessed++;
+                        exportsInfo = moduleGraph.getExportsInfo(module);
+                        cacheable = true;
+                        changed = false;
+                        exportsSpecsFromDependencies.clear();
+                        moduleGraph.freeze();
+                        processDependenciesBlock(module);
+                        moduleGraph.unfreeze();
+                        for (const [dep, exportsSpec] of exportsSpecsFromDependencies) {
+                            processExportsSpec(dep, exportsSpec);
+                        }
+                        if (cacheable) {
+                            modulesToStore.add(module);
+                        }
+                        if (changed) {
+                            notifyDependencies();
+                        }
+                    }
+                    logger.timeEnd('figure out provided exports');
+                    logger.log(`${Math.round((100 * (statFlaggedUncached + statNotCached)) /
+                        (statRestoredFromMemCache +
+                            statRestoredFromCache +
+                            statNotCached +
+                            statFlaggedUncached +
+                            statNoExports))}% of exports of modules have been determined (${statNoExports} no declared exports, ${statNotCached} not cached, ${statFlaggedUncached} flagged uncacheable, ${statRestoredFromCache} from cache, ${statRestoredFromMemCache} from mem cache, ${statQueueItemsProcessed - statNotCached - statFlaggedUncached} additional calculations due to dependencies)`);
+                    logger.time('store provided exports into cache');
+                    neo_async_1.default.each(modulesToStore, (module, callback) => {
+                        if (typeof module.buildInfo.hash !== 'string') {
+                            // not cacheable
+                            return callback();
+                        }
+                        const cachedData = moduleGraph.getExportsInfo(module).getRestoreProvidedData();
+                        const memCache = moduleMemCaches === null || moduleMemCaches === void 0 ? void 0 : moduleMemCaches.get(module);
+                        if (memCache) {
+                            memCache.set(this, cachedData);
+                        }
+                        cache.store(module.identifier(), module.buildInfo.hash, cachedData, callback);
+                    }, err => {
+                        logger.timeEnd('store provided exports into cache');
+                        callback(err);
+                    });
+                });
+            });
+            const providedExportsCache = new WeakMap();
+            compilation.hooks.rebuildModule.tap(PLUGIN_NAME, module => {
+                providedExportsCache.set(module, moduleGraph.getExportsInfo(module).getRestoreProvidedData());
+            });
+            compilation.hooks.finishRebuildingModule.tap(PLUGIN_NAME, module => {
+                moduleGraph.getExportsInfo(module).restoreProvided(providedExportsCache.get(module));
+            });
+        });
+    }
+}
+exports.default = FlagDependencyExportsPlugin;

package/dist/plugins/optimize/FlagDependencyUsagePlugin.d.ts

@@ -0,0 +1,6 @@
+declare class FlagDependencyUsagePlugin {
+    global: any;
+    constructor(global: any);
+    apply(compiler: any): void;
+}
+export default FlagDependencyUsagePlugin;

package/dist/plugins/optimize/FlagDependencyUsagePlugin.js

@@ -0,0 +1,243 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ExportsInfo_1 = require("@/module/ExportsInfo");
+const ArrayQueue_1 = __importDefault(require("@/base/ArrayQueue"));
+const TupleQueue_1 = __importDefault(require("@/base/TupleQueue"));
+const RuntimeHelpers_1 = require("@/module/RuntimeHelpers");
+const OptimizationStages_1 = require("./OptimizationStages");
+const ModuleGraphConnection_1 = require("../../module/ModuleGraphConnection");
+const Dependency_1 = __importDefault(require("../../dependencies/Dependency"));
+const { NO_EXPORTS_REFERENCED, EXPORTS_OBJECT_REFERENCED } = Dependency_1.default;
+const PLUGIN_NAME = 'FlagDependencyUsagePlugin';
+const PLUGIN_LOGGER_NAME = `webpack.${PLUGIN_NAME}`;
+class FlagDependencyUsagePlugin {
+    constructor(global) {
+        this.global = global;
+    }
+    apply(compiler) {
+        compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
+            const moduleGraph = compilation.moduleGraph;
+            compilation.hooks.optimizeDependencies.tap({ name: PLUGIN_NAME, stage: OptimizationStages_1.STAGE_DEFAULT }, modules => {
+                if (compilation.moduleMemCaches) {
+                    throw new Error("optimization.usedExports can't be used with cacheUnaffected as export usage is a global effect");
+                }
+                const logger = compilation.getLogger(PLUGIN_LOGGER_NAME);
+                const exportInfoToModuleMap = new Map();
+                const queue = new TupleQueue_1.default();
+                const processReferencedModule = (module, usedExports, runtime, forceSideEffects) => {
+                    const exportsInfo = moduleGraph.getExportsInfo(module);
+                    if (usedExports.length > 0) {
+                        if (!module.buildMeta || !module.buildMeta.exportsType) {
+                            if (exportsInfo.setUsedWithoutInfo(runtime)) {
+                                queue.enqueue(module, runtime);
+                            }
+                            return;
+                        }
+                        for (const usedExportInfo of usedExports) {
+                            let usedExport;
+                            let canMangle = true;
+                            if (Array.isArray(usedExportInfo)) {
+                                usedExport = usedExportInfo;
+                            }
+                            else {
+                                usedExport = usedExportInfo.name;
+                                canMangle = usedExportInfo.canMangle !== false;
+                            }
+                            if (usedExport.length === 0) {
+                                if (exportsInfo.setUsedInUnknownWay(runtime)) {
+                                    queue.enqueue(module, runtime);
+                                }
+                            }
+                            else {
+                                let currentExportsInfo = exportsInfo;
+                                for (let i = 0; i < usedExport.length; i++) {
+                                    const exportInfo = currentExportsInfo.getExportInfo(usedExport[i]);
+                                    if (canMangle === false) {
+                                        exportInfo.canMangleUse = false;
+                                    }
+                                    const lastOne = i === usedExport.length - 1;
+                                    if (!lastOne) {
+                                        const nestedInfo = exportInfo.getNestedExportsInfo();
+                                        if (nestedInfo) {
+                                            if (exportInfo.setUsedConditionally(used => used === ExportsInfo_1.UsageState.Unused, ExportsInfo_1.UsageState.OnlyPropertiesUsed, runtime)) {
+                                                const currentModule = currentExportsInfo === exportsInfo
+                                                    ? module
+                                                    : exportInfoToModuleMap.get(currentExportsInfo);
+                                                if (currentModule) {
+                                                    queue.enqueue(currentModule, runtime);
+                                                }
+                                            }
+                                            currentExportsInfo = nestedInfo;
+                                            continue;
+                                        }
+                                    }
+                                    if (exportInfo.setUsedConditionally(v => v !== ExportsInfo_1.UsageState.Used, ExportsInfo_1.UsageState.Used, runtime)) {
+                                        const currentModule = currentExportsInfo === exportsInfo
+                                            ? module
+                                            : exportInfoToModuleMap.get(currentExportsInfo);
+                                        if (currentModule) {
+                                            queue.enqueue(currentModule, runtime);
+                                        }
+                                    }
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        // for a module without side effects we stop tracking usage here when no export is used
+                        // This module won't be evaluated in this case
+                        // TODO webpack 6 remove this check
+                        if (!forceSideEffects &&
+                            module.factoryMeta !== undefined &&
+                            module.factoryMeta.sideEffectFree) {
+                            return;
+                        }
+                        if (exportsInfo.setUsedForSideEffectsOnly(runtime)) {
+                            queue.enqueue(module, runtime);
+                        }
+                    }
+                };
+                const processModule = (module, runtime, forceSideEffects) => {
+                    const map = new Map();
+                    const queue = new ArrayQueue_1.default();
+                    queue.enqueue(module);
+                    for (;;) {
+                        const block = queue.dequeue();
+                        if (block === undefined)
+                            break;
+                        for (const b of block.blocks) {
+                            if (!this.global && b.groupOptions && b.groupOptions.entryOptions) {
+                                processModule(b, b.groupOptions.entryOptions.runtime || undefined, true);
+                            }
+                            else {
+                                queue.enqueue(b);
+                            }
+                        }
+                        for (const dep of block.dependencies) {
+                            const connection = moduleGraph.getConnection(dep);
+                            if (!connection || !connection.module) {
+                                continue;
+                            }
+                            const activeState = connection.getActiveState(runtime);
+                            if (activeState === false)
+                                continue;
+                            const { module } = connection;
+                            if (activeState === ModuleGraphConnection_1.TRANSITIVE_ONLY) {
+                                processModule(module, runtime, false);
+                                continue;
+                            }
+                            const oldReferencedExports = map.get(module);
+                            if (oldReferencedExports === EXPORTS_OBJECT_REFERENCED) {
+                                continue;
+                            }
+                            const referencedExports = compilation.getDependencyReferencedExports(dep, runtime);
+                            if (oldReferencedExports === undefined ||
+                                oldReferencedExports === NO_EXPORTS_REFERENCED ||
+                                referencedExports === EXPORTS_OBJECT_REFERENCED) {
+                                map.set(module, referencedExports);
+                            }
+                            else if (oldReferencedExports !== undefined &&
+                                referencedExports === NO_EXPORTS_REFERENCED) {
+                                continue;
+                            }
+                            else {
+                                let exportsMap;
+                                if (Array.isArray(oldReferencedExports)) {
+                                    exportsMap = new Map();
+                                    for (const item of oldReferencedExports) {
+                                        if (Array.isArray(item)) {
+                                            exportsMap.set(item.join('\n'), item);
+                                        }
+                                        else {
+                                            exportsMap.set(item.name.join('\n'), item);
+                                        }
+                                    }
+                                    map.set(module, exportsMap);
+                                }
+                                else {
+                                    exportsMap = oldReferencedExports;
+                                }
+                                for (const item of referencedExports) {
+                                    if (Array.isArray(item)) {
+                                        const key = item.join('\n');
+                                        const oldItem = exportsMap.get(key);
+                                        if (oldItem === undefined) {
+                                            exportsMap.set(key, item);
+                                        }
+                                        // if oldItem is already an array we have to do nothing
+                                        // if oldItem is an ReferencedExport object, we don't have to do anything
+                                        // as canMangle defaults to true for arrays
+                                    }
+                                    else {
+                                        const key = item.name.join('\n');
+                                        const oldItem = exportsMap.get(key);
+                                        if (oldItem === undefined || Array.isArray(oldItem)) {
+                                            exportsMap.set(key, item);
+                                        }
+                                        else {
+                                            exportsMap.set(key, {
+                                                name: item.name,
+                                                canMangle: item.canMangle && oldItem.canMangle,
+                                            });
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    for (const [module, referencedExports] of map) {
+                        if (Array.isArray(referencedExports)) {
+                            processReferencedModule(module, referencedExports, runtime, forceSideEffects);
+                        }
+                        else {
+                            processReferencedModule(module, Array.from(referencedExports.values()), runtime, forceSideEffects);
+                        }
+                    }
+                };
+                logger.time('initialize exports usage');
+                for (const module of modules) {
+                    const exportsInfo = moduleGraph.getExportsInfo(module);
+                    exportInfoToModuleMap.set(exportsInfo, module);
+                    exportsInfo.setHasUseInfo();
+                }
+                logger.timeEnd('initialize exports usage');
+                logger.time('trace exports usage in graph');
+                const processEntryDependency = (dep, runtime) => {
+                    const module = moduleGraph.getModule(dep);
+                    if (module) {
+                        processReferencedModule(module, NO_EXPORTS_REFERENCED, runtime, true);
+                    }
+                };
+                let globalRuntime;
+                for (const [entryName, { dependencies: deps, includeDependencies: includeDeps, options },] of compilation.entries) {
+                    const runtime = this.global
+                        ? undefined
+                        : (0, RuntimeHelpers_1.getEntryRuntime)(compilation, entryName, options);
+                    for (const dep of deps) {
+                        processEntryDependency(dep, runtime);
+                    }
+                    for (const dep of includeDeps) {
+                        processEntryDependency(dep, runtime);
+                    }
+                    globalRuntime = (0, RuntimeHelpers_1.mergeRuntimeOwned)(globalRuntime, runtime);
+                }
+                for (const dep of compilation.globalEntry.dependencies) {
+                    processEntryDependency(dep, globalRuntime);
+                }
+                for (const dep of compilation.globalEntry.includeDependencies) {
+                    processEntryDependency(dep, globalRuntime);
+                }
+                while (queue.length) {
+                    const [module, runtime] = queue.dequeue();
+                    processModule(module, runtime, false);
+                }
+                logger.timeEnd('trace exports usage in graph');
+            });
+        });
+    }
+}
+exports.default = FlagDependencyUsagePlugin;

package/dist/plugins/optimize/FlagEntryExportAsUsedPlugin.d.ts

@@ -0,0 +1,7 @@
+declare class FlagEntryExportAsUsedPlugin {
+    nsObjectUsed: boolean;
+    explanation: string;
+    constructor(nsObjectUsed: boolean, explanation: string);
+    apply(compiler: any): void;
+}
+export default FlagEntryExportAsUsedPlugin;