xhs-mp-pack 1.1.0-beta.0

package/dist/plugins/optimize/FlagEntryExportAsUsedPlugin.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const RuntimeHelpers_1 = require("@/module/RuntimeHelpers");
+const PLUGIN_NAME = 'FlagEntryExportAsUsedPlugin';
+class FlagEntryExportAsUsedPlugin {
+    constructor(nsObjectUsed, explanation) {
+        this.nsObjectUsed = nsObjectUsed;
+        this.explanation = explanation;
+    }
+    apply(compiler) {
+        compiler.hooks.thisCompilation.tap(PLUGIN_NAME, compilation => {
+            const moduleGraph = compilation.moduleGraph;
+            compilation.hooks.seal.tap(PLUGIN_NAME, () => {
+                for (const [entryName, { dependencies: deps, options }] of compilation.entries) {
+                    const runtime = (0, RuntimeHelpers_1.getEntryRuntime)(compilation, entryName, options);
+                    for (const dep of deps) {
+                        const module = moduleGraph.getModule(dep);
+                        if (module) {
+                            const exportsInfo = moduleGraph.getExportsInfo(module);
+                            if (this.nsObjectUsed) {
+                                exportsInfo.setUsedInUnknownWay(runtime);
+                            }
+                            else {
+                                exportsInfo.setAllKnownExportsUsed(runtime);
+                            }
+                            moduleGraph.addExtraReason(module, this.explanation);
+                        }
+                    }
+                }
+            });
+        });
+    }
+}
+exports.default = FlagEntryExportAsUsedPlugin;

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

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

package/dist/plugins/optimize/FlagIncludedChunksPlugin.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class FlagIncludedChunksPlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap('FlagIncludedChunksPlugin', compilation => {
+            compilation.hooks.optimizeChunkIds.tap('FlagIncludedChunksPlugin', chunks => {
+                const chunkGraph = compilation.chunkGraph;
+                // prepare two bit integers for each module
+                // 2^31 is the max number represented as SMI in v8
+                // we want the bits distributed this way:
+                // the bit 2^31 is pretty rar and only one module should get it
+                // so it has a probability of 1 / modulesCount
+                // the first bit (2^0) is the easiest and every module could get it
+                // if it doesn't get a better bit
+                // from bit 2^n to 2^(n+1) there is a probability of p
+                // so 1 / modulesCount == p^31
+                // <=> p = sqrt31(1 / modulesCount)
+                // so we use a modulo of 1 / sqrt31(1 / modulesCount)
+                const moduleBits = new WeakMap();
+                const modulesCount = compilation.modules.size;
+                // precalculate the modulo values for each bit
+                const modulo = 1 / Math.pow(1 / modulesCount, 1 / 31);
+                const modulos = Array.from({ length: 31 }, (x, i) => Math.pow(modulo, i) | 0);
+                // iterate all modules to generate bit values
+                let i = 0;
+                for (const module of compilation.modules) {
+                    let bit = 30;
+                    while (i % modulos[bit] !== 0) {
+                        bit--;
+                    }
+                    moduleBits.set(module, 1 << bit);
+                    i++;
+                }
+                // iterate all chunks to generate bitmaps
+                const chunkModulesHash = new WeakMap();
+                for (const chunk of chunks) {
+                    let hash = 0;
+                    for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+                        hash |= moduleBits.get(module);
+                    }
+                    chunkModulesHash.set(chunk, hash);
+                }
+                for (const chunkA of chunks) {
+                    const chunkAHash = chunkModulesHash.get(chunkA);
+                    const chunkAModulesCount = chunkGraph.getNumberOfChunkModules(chunkA);
+                    if (chunkAModulesCount === 0)
+                        continue;
+                    let bestModule;
+                    for (const module of chunkGraph.getChunkModulesIterable(chunkA)) {
+                        if (bestModule === undefined ||
+                            chunkGraph.getNumberOfModuleChunks(bestModule) >
+                                chunkGraph.getNumberOfModuleChunks(module))
+                            bestModule = module;
+                    }
+                    loopB: for (const chunkB of chunkGraph.getModuleChunksIterable(bestModule)) {
+                        // as we iterate the same iterables twice
+                        // skip if we find ourselves
+                        if (chunkA === chunkB)
+                            continue;
+                        const chunkBModulesCount = chunkGraph.getNumberOfChunkModules(chunkB);
+                        // ids for empty chunks are not included
+                        if (chunkBModulesCount === 0)
+                            continue;
+                        // instead of swapping A and B just bail
+                        // as we loop twice the current A will be B and B then A
+                        if (chunkAModulesCount > chunkBModulesCount)
+                            continue;
+                        // is chunkA in chunkB?
+                        // we do a cheap check for the hash value
+                        const chunkBHash = chunkModulesHash.get(chunkB);
+                        if ((chunkBHash & chunkAHash) !== chunkAHash)
+                            continue;
+                        // compare all modules
+                        for (const m of chunkGraph.getChunkModulesIterable(chunkA)) {
+                            if (!chunkGraph.isModuleInChunk(m, chunkB))
+                                continue loopB;
+                        }
+                        chunkB.ids.push(chunkA.id);
+                    }
+                }
+            });
+        });
+    }
+}
+exports.default = FlagIncludedChunksPlugin;

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

@@ -0,0 +1,20 @@
+import ModuleGraph from '../../module/ModuleGraph';
+import Dependency from '../../dependencies/Dependency';
+declare const topLevelSymbolTag: unique symbol;
+declare const bailout: (parserState: any) => void;
+declare const enable: (parserState: any) => void;
+declare const isEnabled: (parserState: any) => boolean;
+declare const addUsage: (state: any, symbol: TopLevelSymbol | null, usage: string | TopLevelSymbol | true) => void;
+declare const addVariableUsage: (parser: any, name: string, usage: string | TopLevelSymbol | true) => void;
+declare const inferDependencyUsage: (state: any) => void;
+declare const onUsage: (state: any, onUsageCallback: any) => void;
+declare const setTopLevelSymbol: (state: any, symbol: any) => void;
+declare const getTopLevelSymbol: (state: any) => TopLevelSymbol | undefined;
+declare const tagTopLevelSymbol: (parser: any, name: any) => any;
+declare const isDependencyUsedByExports: (dependency: Dependency, usedByExports: Set<string> | boolean, moduleGraph: ModuleGraph, runtime: any) => boolean;
+declare const getDependencyUsedByExportsCondition: (dependency: Dependency, usedByExports: Set<string> | boolean | undefined, moduleGraph: ModuleGraph) => false | ((connections: any, runtime: any) => boolean) | null;
+declare class TopLevelSymbol {
+    name: string;
+    constructor(name: any);
+}
+export { topLevelSymbolTag, bailout, enable, isEnabled, addUsage, tagTopLevelSymbol, isDependencyUsedByExports, getDependencyUsedByExportsCondition, TopLevelSymbol, onUsage, addVariableUsage, setTopLevelSymbol, inferDependencyUsage, getTopLevelSymbol, };

package/dist/plugins/optimize/InnerGraph.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTopLevelSymbol = exports.inferDependencyUsage = exports.setTopLevelSymbol = exports.addVariableUsage = exports.onUsage = exports.TopLevelSymbol = exports.getDependencyUsedByExportsCondition = exports.isDependencyUsedByExports = exports.tagTopLevelSymbol = exports.addUsage = exports.isEnabled = exports.enable = exports.bailout = exports.topLevelSymbolTag = void 0;
+const ExportsInfo_1 = require("@/module/ExportsInfo");
+const parserStateMap = new WeakMap();
+const topLevelSymbolTag = Symbol('top level symbol');
+exports.topLevelSymbolTag = topLevelSymbolTag;
+function getState(parserState) {
+    return parserStateMap.get(parserState);
+}
+const bailout = parserState => {
+    parserStateMap.set(parserState, false);
+};
+exports.bailout = bailout;
+const enable = parserState => {
+    const state = parserStateMap.get(parserState);
+    if (state === false) {
+        return;
+    }
+    parserStateMap.set(parserState, {
+        innerGraph: new Map(),
+        currentTopLevelSymbol: undefined,
+        usageCallbackMap: new Map(),
+    });
+};
+exports.enable = enable;
+const isEnabled = parserState => {
+    const state = parserStateMap.get(parserState);
+    return !!state;
+};
+exports.isEnabled = isEnabled;
+const addUsage = (state, symbol, usage) => {
+    const innerGraphState = getState(state);
+    if (innerGraphState) {
+        const { innerGraph } = innerGraphState;
+        const info = innerGraph.get(symbol);
+        if (usage === true) {
+            innerGraph.set(symbol, true);
+        }
+        else if (info === undefined) {
+            innerGraph.set(symbol, new Set([usage]));
+        }
+        else if (info !== true) {
+            info.add(usage);
+        }
+    }
+};
+exports.addUsage = addUsage;
+const addVariableUsage = (parser, name, usage) => {
+    const symbol = parser.getTagData(name, topLevelSymbolTag) || tagTopLevelSymbol(parser, name);
+    if (symbol) {
+        addUsage(parser.state, symbol, usage);
+    }
+};
+exports.addVariableUsage = addVariableUsage;
+const inferDependencyUsage = state => {
+    const innerGraphState = getState(state);
+    if (!innerGraphState) {
+        return;
+    }
+    const { innerGraph, usageCallbackMap } = innerGraphState;
+    const processed = new Map();
+    // flatten graph to terminal nodes (string, undefined or true)
+    const nonTerminal = new Set(innerGraph.keys());
+    while (nonTerminal.size > 0) {
+        for (const key of nonTerminal) {
+            let newSet = new Set();
+            let isTerminal = true;
+            const value = innerGraph.get(key);
+            let alreadyProcessed = processed.get(key);
+            if (alreadyProcessed === undefined) {
+                alreadyProcessed = new Set();
+                processed.set(key, alreadyProcessed);
+            }
+            if (value !== true && value !== undefined) {
+                for (const item of value) {
+                    alreadyProcessed.add(item);
+                }
+                for (const item of value) {
+                    if (typeof item === 'string') {
+                        newSet.add(item);
+                    }
+                    else {
+                        const itemValue = innerGraph.get(item);
+                        if (itemValue === true) {
+                            newSet = true;
+                            break;
+                        }
+                        if (itemValue !== undefined) {
+                            for (const i of itemValue) {
+                                if (i === key)
+                                    continue;
+                                if (alreadyProcessed.has(i))
+                                    continue;
+                                newSet.add(i);
+                                if (typeof i !== 'string') {
+                                    isTerminal = false;
+                                }
+                            }
+                        }
+                    }
+                }
+                if (newSet === true) {
+                    innerGraph.set(key, true);
+                }
+                else if (newSet.size === 0) {
+                    innerGraph.set(key, undefined);
+                }
+                else {
+                    innerGraph.set(key, newSet);
+                }
+            }
+            if (isTerminal) {
+                nonTerminal.delete(key);
+                // For the global key, merge with all other keys
+                if (key === null) {
+                    const globalValue = innerGraph.get(null);
+                    if (globalValue) {
+                        for (const [key, value] of innerGraph) {
+                            if (key !== null && value !== true) {
+                                if (globalValue === true) {
+                                    innerGraph.set(key, true);
+                                }
+                                else {
+                                    const newSet = new Set(value);
+                                    for (const item of globalValue) {
+                                        newSet.add(item);
+                                    }
+                                    innerGraph.set(key, newSet);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    for (const [symbol, callbacks] of usageCallbackMap) {
+        const usage = innerGraph.get(symbol);
+        for (const callback of callbacks) {
+            callback(usage === undefined ? false : usage);
+        }
+    }
+};
+exports.inferDependencyUsage = inferDependencyUsage;
+const onUsage = (state, onUsageCallback) => {
+    const innerGraphState = getState(state);
+    if (innerGraphState) {
+        const { usageCallbackMap, currentTopLevelSymbol } = innerGraphState;
+        if (currentTopLevelSymbol) {
+            let callbacks = usageCallbackMap.get(currentTopLevelSymbol);
+            if (callbacks === undefined) {
+                callbacks = new Set();
+                usageCallbackMap.set(currentTopLevelSymbol, callbacks);
+            }
+            callbacks.add(onUsageCallback);
+        }
+        else {
+            onUsageCallback(true);
+        }
+    }
+    else {
+        onUsageCallback(undefined);
+    }
+};
+exports.onUsage = onUsage;
+const setTopLevelSymbol = (state, symbol) => {
+    const innerGraphState = getState(state);
+    if (innerGraphState) {
+        innerGraphState.currentTopLevelSymbol = symbol;
+    }
+};
+exports.setTopLevelSymbol = setTopLevelSymbol;
+const getTopLevelSymbol = state => {
+    const innerGraphState = getState(state);
+    if (innerGraphState) {
+        return innerGraphState.currentTopLevelSymbol;
+    }
+};
+exports.getTopLevelSymbol = getTopLevelSymbol;
+const tagTopLevelSymbol = (parser, name) => {
+    const innerGraphState = getState(parser.state);
+    if (!innerGraphState)
+        return;
+    parser.defineVariable(name);
+    const existingTag = parser.getTagData(name, topLevelSymbolTag);
+    if (existingTag) {
+        return existingTag;
+    }
+    const fn = new TopLevelSymbol(name);
+    parser.tagVariable(name, topLevelSymbolTag, fn);
+    return fn;
+};
+exports.tagTopLevelSymbol = tagTopLevelSymbol;
+const isDependencyUsedByExports = (dependency, usedByExports, moduleGraph, runtime) => {
+    if (usedByExports === false)
+        return false;
+    if (usedByExports !== true && usedByExports !== undefined) {
+        const selfModule = moduleGraph.getParentModule(dependency);
+        const exportsInfo = moduleGraph.getExportsInfo(selfModule);
+        let used = false;
+        for (const exportName of usedByExports) {
+            if (exportsInfo.getUsed(exportName, runtime) !== ExportsInfo_1.UsageState.Unused)
+                used = true;
+        }
+        if (!used)
+            return false;
+    }
+    return true;
+};
+exports.isDependencyUsedByExports = isDependencyUsedByExports;
+const getDependencyUsedByExportsCondition = (dependency, usedByExports, moduleGraph) => {
+    if (usedByExports === false)
+        return false;
+    if (usedByExports !== true && usedByExports !== undefined) {
+        const selfModule = moduleGraph.getParentModule(dependency);
+        const exportsInfo = moduleGraph.getExportsInfo(selfModule);
+        return (connections, runtime) => {
+            for (const exportName of usedByExports) {
+                if (exportsInfo.getUsed(exportName, runtime) !== ExportsInfo_1.UsageState.Unused)
+                    return true;
+            }
+            return false;
+        };
+    }
+    return null;
+};
+exports.getDependencyUsedByExportsCondition = getDependencyUsedByExportsCondition;
+class TopLevelSymbol {
+    constructor(name) {
+        this.name = name;
+    }
+}
+exports.TopLevelSymbol = TopLevelSymbol;

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

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

package/dist/plugins/optimize/InnerGraphPlugin.js

@@ -0,0 +1,289 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ModuleTypeConstants_1 = require("@/module/ModuleTypeConstants");
+const PureExpressionDependency_1 = __importDefault(require("../../dependencies/PureExpressionDependency"));
+const InnerGraph = __importStar(require("./InnerGraph"));
+const { topLevelSymbolTag } = InnerGraph;
+const PLUGIN_NAME = 'InnerGraphPlugin';
+class InnerGraphPlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation, { normalModuleFactory }) => {
+            const logger = compilation.getLogger('webpack.InnerGraphPlugin');
+            compilation.dependencyTemplates.set(PureExpressionDependency_1.default, new PureExpressionDependency_1.default.Template());
+            const handler = (parser, parserOptions) => {
+                const onUsageSuper = sup => {
+                    InnerGraph.onUsage(parser.state, usedByExports => {
+                        switch (usedByExports) {
+                            case undefined:
+                            case true:
+                                return;
+                            default: {
+                                const dep = new PureExpressionDependency_1.default(sup.range);
+                                dep.loc = sup.loc;
+                                dep.usedByExports = usedByExports;
+                                parser.state.module.addDependency(dep);
+                                break;
+                            }
+                        }
+                    });
+                };
+                parser.hooks.program.tap(PLUGIN_NAME, () => {
+                    InnerGraph.enable(parser.state);
+                });
+                parser.hooks.finish.tap(PLUGIN_NAME, () => {
+                    if (!InnerGraph.isEnabled(parser.state))
+                        return;
+                    logger.time('infer dependency usage');
+                    InnerGraph.inferDependencyUsage(parser.state);
+                    logger.timeAggregate('infer dependency usage');
+                });
+                // During prewalking the following datastructures are filled with
+                // nodes that have a TopLevelSymbol assigned and
+                // variables are tagged with the assigned TopLevelSymbol
+                // We differ 3 types of nodes:
+                // 1. full statements (export default, function declaration)
+                // 2. classes (class declaration, class expression)
+                // 3. variable declarators (const x = ...)
+                const statementWithTopLevelSymbol = new WeakMap();
+                const statementPurePart = new WeakMap();
+                const classWithTopLevelSymbol = new WeakMap();
+                const declWithTopLevelSymbol = new WeakMap();
+                const pureDeclarators = new WeakSet();
+                // The following hooks are used during prewalking:
+                parser.hooks.preStatement.tap(PLUGIN_NAME, statement => {
+                    if (!InnerGraph.isEnabled(parser.state))
+                        return;
+                    if (parser.scope.topLevelScope === true) {
+                        if (statement.type === 'FunctionDeclaration') {
+                            const name = statement.id ? statement.id.name : '*default*';
+                            const fn = InnerGraph.tagTopLevelSymbol(parser, name);
+                            statementWithTopLevelSymbol.set(statement, fn);
+                            return true;
+                        }
+                    }
+                });
+                parser.hooks.blockPreStatement.tap(PLUGIN_NAME, statement => {
+                    if (!InnerGraph.isEnabled(parser.state))
+                        return;
+                    if (parser.scope.topLevelScope === true) {
+                        if (statement.type === 'ClassDeclaration' &&
+                            parser.isPure(statement, statement.range[0])) {
+                            const name = statement.id ? statement.id.name : '*default*';
+                            const fn = InnerGraph.tagTopLevelSymbol(parser, name);
+                            classWithTopLevelSymbol.set(statement, fn);
+                            return true;
+                        }
+                        if (statement.type === 'ExportDefaultDeclaration') {
+                            const name = '*default*';
+                            const fn = InnerGraph.tagTopLevelSymbol(parser, name);
+                            const decl = statement.declaration;
+                            if ((decl.type === 'ClassExpression' || decl.type === 'ClassDeclaration') &&
+                                parser.isPure(decl, decl.range[0])) {
+                                classWithTopLevelSymbol.set(decl, fn);
+                            }
+                            else if (parser.isPure(decl, statement.range[0])) {
+                                statementWithTopLevelSymbol.set(statement, fn);
+                                if (!decl.type.endsWith('FunctionExpression') &&
+                                    !decl.type.endsWith('Declaration') &&
+                                    decl.type !== 'Literal') {
+                                    statementPurePart.set(statement, decl);
+                                }
+                            }
+                        }
+                    }
+                });
+                parser.hooks.preDeclarator.tap(PLUGIN_NAME, (decl, statement) => {
+                    if (!InnerGraph.isEnabled(parser.state))
+                        return;
+                    if (parser.scope.topLevelScope === true && decl.init && decl.id.type === 'Identifier') {
+                        const name = decl.id.name;
+                        if (decl.init.type === 'ClassExpression' &&
+                            parser.isPure(decl.init, decl.id.range[1])) {
+                            const fn = InnerGraph.tagTopLevelSymbol(parser, name);
+                            classWithTopLevelSymbol.set(decl.init, fn);
+                        }
+                        else if (parser.isPure(decl.init, decl.id.range[1])) {
+                            const fn = InnerGraph.tagTopLevelSymbol(parser, name);
+                            declWithTopLevelSymbol.set(decl, fn);
+                            if (!decl.init.type.endsWith('FunctionExpression') && decl.init.type !== 'Literal') {
+                                pureDeclarators.add(decl);
+                            }
+                            return true;
+                        }
+                    }
+                });
+                // During real walking we set the TopLevelSymbol state to the assigned
+                // TopLevelSymbol by using the fill datastructures.
+                // In addition to tracking TopLevelSymbols, we sometimes need to
+                // add a PureExpressionDependency. This is needed to skip execution
+                // of pure expressions, even when they are not dropped due to
+                // minimizing. Otherwise symbols used there might not exist anymore
+                // as they are removed as unused by this optimization
+                // When we find a reference to a TopLevelSymbol, we register a
+                // TopLevelSymbol dependency from TopLevelSymbol in state to the
+                // referenced TopLevelSymbol. This way we get a graph of all
+                // TopLevelSymbols.
+                // The following hooks are called during walking:
+                parser.hooks.statement.tap(PLUGIN_NAME, statement => {
+                    if (!InnerGraph.isEnabled(parser.state))
+                        return;
+                    if (parser.scope.topLevelScope === true) {
+                        InnerGraph.setTopLevelSymbol(parser.state, undefined);
+                        const fn = statementWithTopLevelSymbol.get(statement);
+                        if (fn) {
+                            InnerGraph.setTopLevelSymbol(parser.state, fn);
+                            const purePart = statementPurePart.get(statement);
+                            if (purePart) {
+                                InnerGraph.onUsage(parser.state, usedByExports => {
+                                    switch (usedByExports) {
+                                        case undefined:
+                                        case true:
+                                            return;
+                                        default: {
+                                            const dep = new PureExpressionDependency_1.default(purePart.range);
+                                            dep.loc = statement.loc;
+                                            dep.usedByExports = usedByExports;
+                                            parser.state.module.addDependency(dep);
+                                            break;
+                                        }
+                                    }
+                                });
+                            }
+                        }
+                    }
+                });
+                parser.hooks.classExtendsExpression.tap(PLUGIN_NAME, (expr, statement) => {
+                    if (!InnerGraph.isEnabled(parser.state))
+                        return;
+                    if (parser.scope.topLevelScope === true) {
+                        const fn = classWithTopLevelSymbol.get(statement);
+                        if (fn &&
+                            parser.isPure(expr, statement.id ? statement.id.range[1] : statement.range[0])) {
+                            InnerGraph.setTopLevelSymbol(parser.state, fn);
+                            onUsageSuper(expr);
+                        }
+                    }
+                });
+                parser.hooks.classBodyElement.tap(PLUGIN_NAME, (element, classDefinition) => {
+                    if (!InnerGraph.isEnabled(parser.state))
+                        return;
+                    if (parser.scope.topLevelScope === true) {
+                        const fn = classWithTopLevelSymbol.get(classDefinition);
+                        if (fn) {
+                            InnerGraph.setTopLevelSymbol(parser.state, undefined);
+                        }
+                    }
+                });
+                parser.hooks.classBodyValue.tap(PLUGIN_NAME, (expression, element, classDefinition) => {
+                    if (!InnerGraph.isEnabled(parser.state))
+                        return;
+                    if (parser.scope.topLevelScope === true) {
+                        const fn = classWithTopLevelSymbol.get(classDefinition);
+                        if (fn) {
+                            if (!element.static ||
+                                parser.isPure(expression, element.key ? element.key.range[1] : element.range[0])) {
+                                InnerGraph.setTopLevelSymbol(parser.state, fn);
+                                if (element.type !== 'MethodDefinition' && element.static) {
+                                    InnerGraph.onUsage(parser.state, usedByExports => {
+                                        switch (usedByExports) {
+                                            case undefined:
+                                            case true:
+                                                return;
+                                            default: {
+                                                const dep = new PureExpressionDependency_1.default(expression.range);
+                                                dep.loc = expression.loc;
+                                                dep.usedByExports = usedByExports;
+                                                parser.state.module.addDependency(dep);
+                                                break;
+                                            }
+                                        }
+                                    });
+                                }
+                            }
+                            else {
+                                InnerGraph.setTopLevelSymbol(parser.state, undefined);
+                            }
+                        }
+                    }
+                });
+                parser.hooks.declarator.tap(PLUGIN_NAME, (decl, statement) => {
+                    if (!InnerGraph.isEnabled(parser.state))
+                        return;
+                    const fn = declWithTopLevelSymbol.get(decl);
+                    if (fn) {
+                        InnerGraph.setTopLevelSymbol(parser.state, fn);
+                        if (pureDeclarators.has(decl)) {
+                            if (decl.init.type === 'ClassExpression') {
+                                if (decl.init.superClass) {
+                                    onUsageSuper(decl.init.superClass);
+                                }
+                            }
+                            else {
+                                InnerGraph.onUsage(parser.state, usedByExports => {
+                                    switch (usedByExports) {
+                                        case undefined:
+                                        case true:
+                                            return;
+                                        default: {
+                                            const dep = new PureExpressionDependency_1.default(decl.init.range);
+                                            dep.loc = decl.loc;
+                                            dep.usedByExports = usedByExports;
+                                            parser.state.module.addDependency(dep);
+                                            break;
+                                        }
+                                    }
+                                });
+                            }
+                        }
+                        parser.walkExpression(decl.init);
+                        InnerGraph.setTopLevelSymbol(parser.state, undefined);
+                        return true;
+                    }
+                });
+                parser.hooks.expression.for(topLevelSymbolTag).tap(PLUGIN_NAME, () => {
+                    const topLevelSymbol = parser.currentTagData;
+                    const currentTopLevelSymbol = InnerGraph.getTopLevelSymbol(parser.state);
+                    InnerGraph.addUsage(parser.state, topLevelSymbol, currentTopLevelSymbol || true);
+                });
+                parser.hooks.assign.for(topLevelSymbolTag).tap(PLUGIN_NAME, expr => {
+                    if (!InnerGraph.isEnabled(parser.state))
+                        return;
+                    if (expr.operator === '=')
+                        return true;
+                });
+            };
+            normalModuleFactory.hooks.parser.for(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_AUTO).tap(PLUGIN_NAME, handler);
+            normalModuleFactory.hooks.parser.for(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_ESM).tap(PLUGIN_NAME, handler);
+            compilation.hooks.finishModules.tap(PLUGIN_NAME, () => {
+                logger.timeAggregateEnd('infer dependency usage');
+            });
+        });
+    }
+}
+exports.default = InnerGraphPlugin;