webpack 5.59.0 → 5.94.0

package/lib/optimize/EnsureChunkConditionsPlugin.js

@@ -21,6 +21,9 @@ class EnsureChunkConditionsPlugin {
 		compiler.hooks.compilation.tap(
 			"EnsureChunkConditionsPlugin",
 			compilation => {
+				/**
+				 * @param {Iterable<Chunk>} chunks the chunks
+				 */
 				const handler = chunks => {
 					const chunkGraph = compilation.chunkGraph;
 					// These sets are hoisted here to save memory
@@ -53,7 +56,7 @@ class EnsureChunkConditionsPlugin {
 							// We reached the entrypoint: fail
 							if (chunkGroup.isInitial()) {
 								throw new Error(
-									"Cannot fullfil chunk condition of " + module.identifier()
+									`Cannot fulfil chunk condition of ${module.identifier()}`
 								);
 							}
 							// Try placing in all parents

package/lib/optimize/FlagIncludedChunksPlugin.js

@@ -6,6 +6,7 @@
 "use strict";
 
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Chunk").ChunkId} ChunkId */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
 
@@ -38,10 +39,10 @@ class FlagIncludedChunksPlugin {
 					const modulesCount = compilation.modules.size;
 
 					// precalculate the modulo values for each bit
-					const modulo = 1 / Math.pow(1 / modulesCount, 1 / 31);
+					const modulo = 1 / (1 / modulesCount) ** (1 / 31);
 					const modulos = Array.from(
 						{ length: 31 },
-						(x, i) => Math.pow(modulo, i) | 0
+						(x, i) => (modulo ** i) | 0
 					);
 
 					// iterate all modules to generate bit values
@@ -61,17 +62,19 @@ class FlagIncludedChunksPlugin {
 					for (const chunk of chunks) {
 						let hash = 0;
 						for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
-							hash |= moduleBits.get(module);
+							hash |= /** @type {number} */ (moduleBits.get(module));
 						}
 						chunkModulesHash.set(chunk, hash);
 					}
 
 					for (const chunkA of chunks) {
-						const chunkAHash = chunkModulesHash.get(chunkA);
+						const chunkAHash =
+							/** @type {number} */
+							(chunkModulesHash.get(chunkA));
 						const chunkAModulesCount =
 							chunkGraph.getNumberOfChunkModules(chunkA);
 						if (chunkAModulesCount === 0) continue;
-						let bestModule = undefined;
+						let bestModule;
 						for (const module of chunkGraph.getChunkModulesIterable(chunkA)) {
 							if (
 								bestModule === undefined ||
@@ -81,7 +84,7 @@ class FlagIncludedChunksPlugin {
 								bestModule = module;
 						}
 						loopB: for (const chunkB of chunkGraph.getModuleChunksIterable(
-							bestModule
+							/** @type {Module} */ (bestModule)
 						)) {
 							// as we iterate the same iterables twice
 							// skip if we find ourselves
@@ -100,14 +103,17 @@ class FlagIncludedChunksPlugin {
 							// is chunkA in chunkB?
 
 							// we do a cheap check for the hash value
-							const chunkBHash = chunkModulesHash.get(chunkB);
+							const chunkBHash =
+								/** @type {number} */
+								(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);
+							/** @type {ChunkId[]} */
+							(chunkB.ids).push(/** @type {ChunkId} */ (chunkA.id));
 						}
 					}
 				}

package/lib/optimize/InnerGraph.js

@@ -9,6 +9,7 @@ const { UsageState } = require("../ExportsInfo");
 
 /** @typedef {import("estree").Node} AnyNode */
 /** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
@@ -16,11 +17,11 @@ const { UsageState } = require("../ExportsInfo");
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-/** @typedef {Map<TopLevelSymbol | null, Set<string | TopLevelSymbol> | true>} InnerGraph */
+/** @typedef {Map<TopLevelSymbol | null, Set<string | TopLevelSymbol> | true | undefined>} InnerGraph */
 /** @typedef {function(boolean | Set<string> | undefined): void} UsageCallback */
 
 /**
- * @typedef {Object} StateObject
+ * @typedef {object} StateObject
  * @property {InnerGraph} innerGraph
  * @property {TopLevelSymbol=} currentTopLevelSymbol
  * @property {Map<TopLevelSymbol, Set<UsageCallback>>} usageCallbackMap
@@ -34,7 +35,7 @@ const topLevelSymbolTag = Symbol("top level symbol");
 
 /**
  * @param {ParserState} parserState parser state
- * @returns {State} state
+ * @returns {State | undefined} state
  */
 function getState(parserState) {
 	return parserStateMap.get(parserState);
@@ -44,7 +45,7 @@ function getState(parserState) {
  * @param {ParserState} parserState parser state
  * @returns {void}
  */
-exports.bailout = parserState => {
+module.exports.bailout = parserState => {
 	parserStateMap.set(parserState, false);
 };
 
@@ -52,7 +53,7 @@ exports.bailout = parserState => {
  * @param {ParserState} parserState parser state
  * @returns {void}
  */
-exports.enable = parserState => {
+module.exports.enable = parserState => {
 	const state = parserStateMap.get(parserState);
 	if (state === false) {
 		return;
@@ -68,9 +69,9 @@ exports.enable = parserState => {
  * @param {ParserState} parserState parser state
  * @returns {boolean} true, when enabled
  */
-exports.isEnabled = parserState => {
+module.exports.isEnabled = parserState => {
 	const state = parserStateMap.get(parserState);
-	return !!state;
+	return Boolean(state);
 };
 
 /**
@@ -79,7 +80,7 @@ exports.isEnabled = parserState => {
  * @param {string | TopLevelSymbol | true} usage usage data
  * @returns {void}
  */
-exports.addUsage = (state, symbol, usage) => {
+module.exports.addUsage = (state, symbol, usage) => {
 	const innerGraphState = getState(state);
 
 	if (innerGraphState) {
@@ -101,13 +102,13 @@ exports.addUsage = (state, symbol, usage) => {
  * @param {string | TopLevelSymbol | true} usage usage data
  * @returns {void}
  */
-exports.addVariableUsage = (parser, name, usage) => {
+module.exports.addVariableUsage = (parser, name, usage) => {
 	const symbol =
 		/** @type {TopLevelSymbol} */ (
 			parser.getTagData(name, topLevelSymbolTag)
-		) || exports.tagTopLevelSymbol(parser, name);
+		) || module.exports.tagTopLevelSymbol(parser, name);
 	if (symbol) {
-		exports.addUsage(parser.state, symbol, usage);
+		module.exports.addUsage(parser.state, symbol, usage);
 	}
 };
 
@@ -115,7 +116,7 @@ exports.addVariableUsage = (parser, name, usage) => {
  * @param {ParserState} state parser state
  * @returns {void}
  */
-exports.inferDependencyUsage = state => {
+module.exports.inferDependencyUsage = state => {
 	const innerGraphState = getState(state);
 
 	if (!innerGraphState) {
@@ -211,7 +212,7 @@ exports.inferDependencyUsage = state => {
  * @param {ParserState} state parser state
  * @param {UsageCallback} onUsageCallback on usage callback
  */
-exports.onUsage = (state, onUsageCallback) => {
+module.exports.onUsage = (state, onUsageCallback) => {
 	const innerGraphState = getState(state);
 
 	if (innerGraphState) {
@@ -235,9 +236,9 @@ exports.onUsage = (state, onUsageCallback) => {
 
 /**
  * @param {ParserState} state parser state
- * @param {TopLevelSymbol} symbol the symbol
+ * @param {TopLevelSymbol | undefined} symbol the symbol
  */
-exports.setTopLevelSymbol = (state, symbol) => {
+module.exports.setTopLevelSymbol = (state, symbol) => {
 	const innerGraphState = getState(state);
 
 	if (innerGraphState) {
@@ -249,7 +250,7 @@ exports.setTopLevelSymbol = (state, symbol) => {
  * @param {ParserState} state parser state
  * @returns {TopLevelSymbol|void} usage data
  */
-exports.getTopLevelSymbol = state => {
+module.exports.getTopLevelSymbol = state => {
 	const innerGraphState = getState(state);
 
 	if (innerGraphState) {
@@ -260,9 +261,9 @@ exports.getTopLevelSymbol = state => {
 /**
  * @param {JavascriptParser} parser parser
  * @param {string} name name of variable
- * @returns {TopLevelSymbol} symbol
+ * @returns {TopLevelSymbol | undefined} symbol
  */
-exports.tagTopLevelSymbol = (parser, name) => {
+module.exports.tagTopLevelSymbol = (parser, name) => {
 	const innerGraphState = getState(parser.state);
 	if (!innerGraphState) return;
 
@@ -287,7 +288,7 @@ exports.tagTopLevelSymbol = (parser, name) => {
  * @param {RuntimeSpec} runtime runtime
  * @returns {boolean} false, when unused. Otherwise true
  */
-exports.isDependencyUsedByExports = (
+module.exports.isDependencyUsedByExports = (
 	dependency,
 	usedByExports,
 	moduleGraph,
@@ -295,7 +296,9 @@ exports.isDependencyUsedByExports = (
 ) => {
 	if (usedByExports === false) return false;
 	if (usedByExports !== true && usedByExports !== undefined) {
-		const selfModule = moduleGraph.getParentModule(dependency);
+		const selfModule =
+			/** @type {Module} */
+			(moduleGraph.getParentModule(dependency));
 		const exportsInfo = moduleGraph.getExportsInfo(selfModule);
 		let used = false;
 		for (const exportName of usedByExports) {
@@ -309,18 +312,20 @@ exports.isDependencyUsedByExports = (
 
 /**
  * @param {Dependency} dependency the dependency
- * @param {Set<string> | boolean} usedByExports usedByExports info
+ * @param {Set<string> | boolean | undefined} usedByExports usedByExports info
  * @param {ModuleGraph} moduleGraph moduleGraph
  * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
  */
-exports.getDependencyUsedByExportsCondition = (
+module.exports.getDependencyUsedByExportsCondition = (
 	dependency,
 	usedByExports,
 	moduleGraph
 ) => {
 	if (usedByExports === false) return false;
 	if (usedByExports !== true && usedByExports !== undefined) {
-		const selfModule = moduleGraph.getParentModule(dependency);
+		const selfModule =
+			/** @type {Module} */
+			(moduleGraph.getParentModule(dependency));
 		const exportsInfo = moduleGraph.getExportsInfo(selfModule);
 		return (connections, runtime) => {
 			for (const exportName of usedByExports) {
@@ -342,5 +347,5 @@ class TopLevelSymbol {
 	}
 }
 
-exports.TopLevelSymbol = TopLevelSymbol;
-exports.topLevelSymbolTag = topLevelSymbolTag;
+module.exports.TopLevelSymbol = TopLevelSymbol;
+module.exports.topLevelSymbolTag = topLevelSymbolTag;

package/lib/optimize/InnerGraphPlugin.js

@@ -5,6 +5,10 @@
 
 "use strict";
 
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("../ModuleTypeConstants");
 const PureExpressionDependency = require("../dependencies/PureExpressionDependency");
 const InnerGraph = require("./InnerGraph");
 
@@ -12,15 +16,20 @@ const InnerGraph = require("./InnerGraph");
 /** @typedef {import("estree").ClassExpression} ClassExpressionNode */
 /** @typedef {import("estree").Node} Node */
 /** @typedef {import("estree").VariableDeclarator} VariableDeclaratorNode */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../dependencies/HarmonyImportSpecifierDependency")} HarmonyImportSpecifierDependency */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("./InnerGraph").InnerGraph} InnerGraph */
 /** @typedef {import("./InnerGraph").TopLevelSymbol} TopLevelSymbol */
 
 const { topLevelSymbolTag } = InnerGraph;
 
+const PLUGIN_NAME = "InnerGraphPlugin";
+
 class InnerGraphPlugin {
 	/**
 	 * Apply the plugin
@@ -29,7 +38,7 @@ class InnerGraphPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"InnerGraphPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				const logger = compilation.getLogger("webpack.InnerGraphPlugin");
 
@@ -40,7 +49,7 @@ class InnerGraphPlugin {
 
 				/**
 				 * @param {JavascriptParser} parser the parser
-				 * @param {Object} parserOptions options
+				 * @param {JavascriptParserOptions} parserOptions options
 				 * @returns {void}
 				 */
 				const handler = (parser, parserOptions) => {
@@ -61,11 +70,11 @@ class InnerGraphPlugin {
 						});
 					};
 
-					parser.hooks.program.tap("InnerGraphPlugin", () => {
+					parser.hooks.program.tap(PLUGIN_NAME, () => {
 						InnerGraph.enable(parser.state);
 					});
 
-					parser.hooks.finish.tap("InnerGraphPlugin", () => {
+					parser.hooks.finish.tap(PLUGIN_NAME, () => {
 						if (!InnerGraph.isEnabled(parser.state)) return;
 
 						logger.time("infer dependency usage");
@@ -97,24 +106,31 @@ class InnerGraphPlugin {
 
 					// The following hooks are used during prewalking:
 
-					parser.hooks.preStatement.tap("InnerGraphPlugin", statement => {
+					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;
-							}
+						if (
+							parser.scope.topLevelScope === true &&
+							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("InnerGraphPlugin", statement => {
+					parser.hooks.blockPreStatement.tap(PLUGIN_NAME, statement => {
 						if (!InnerGraph.isEnabled(parser.state)) return;
 
 						if (parser.scope.topLevelScope === true) {
-							if (statement.type === "ClassDeclaration") {
+							if (
+								statement.type === "ClassDeclaration" &&
+								parser.isPure(
+									statement,
+									/** @type {Range} */ (statement.range)[0]
+								)
+							) {
 								const name = statement.id ? statement.id.name : "*default*";
 								const fn = InnerGraph.tagTopLevelSymbol(parser, name);
 								classWithTopLevelSymbol.set(statement, fn);
@@ -125,11 +141,14 @@ class InnerGraphPlugin {
 								const fn = InnerGraph.tagTopLevelSymbol(parser, name);
 								const decl = statement.declaration;
 								if (
-									decl.type === "ClassExpression" ||
-									decl.type === "ClassDeclaration"
+									(decl.type === "ClassExpression" ||
+										decl.type === "ClassDeclaration") &&
+									parser.isPure(decl, /** @type {Range} */ (decl.range)[0])
 								) {
 									classWithTopLevelSymbol.set(decl, fn);
-								} else if (parser.isPure(decl, statement.range[0])) {
+								} else if (
+									parser.isPure(decl, /** @type {Range} */ (statement.range)[0])
+								) {
 									statementWithTopLevelSymbol.set(statement, fn);
 									if (
 										!decl.type.endsWith("FunctionExpression") &&
@@ -143,33 +162,40 @@ class InnerGraphPlugin {
 						}
 					});
 
-					parser.hooks.preDeclarator.tap(
-						"InnerGraphPlugin",
-						(decl, statement) => {
-							if (!InnerGraph.isEnabled(parser.state)) return;
+					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 (
-								parser.scope.topLevelScope === true &&
-								decl.init &&
-								decl.id.type === "Identifier"
+								decl.init.type === "ClassExpression" &&
+								parser.isPure(
+									decl.init,
+									/** @type {Range} */ (decl.id.range)[1]
+								)
 							) {
-								const name = decl.id.name;
-								if (decl.init.type === "ClassExpression") {
-									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;
+								const fn = InnerGraph.tagTopLevelSymbol(parser, name);
+								classWithTopLevelSymbol.set(decl.init, fn);
+							} else if (
+								parser.isPure(
+									decl.init,
+									/** @type {Range} */ (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);
 								}
 							}
 						}
-					);
+					});
 
 					// During real walking we set the TopLevelSymbol state to the assigned
 					// TopLevelSymbol by using the fill datastructures.
@@ -187,7 +213,7 @@ class InnerGraphPlugin {
 
 					// The following hooks are called during walking:
 
-					parser.hooks.statement.tap("InnerGraphPlugin", statement => {
+					parser.hooks.statement.tap(PLUGIN_NAME, statement => {
 						if (!InnerGraph.isEnabled(parser.state)) return;
 						if (parser.scope.topLevelScope === true) {
 							InnerGraph.setTopLevelSymbol(parser.state, undefined);
@@ -204,9 +230,11 @@ class InnerGraphPlugin {
 												return;
 											default: {
 												const dep = new PureExpressionDependency(
-													purePart.range
+													/** @type {Range} */ (purePart.range)
 												);
-												dep.loc = statement.loc;
+												dep.loc =
+													/** @type {DependencyLocation} */
+													(statement.loc);
 												dep.usedByExports = usedByExports;
 												parser.state.module.addDependency(dep);
 												break;
@@ -219,7 +247,7 @@ class InnerGraphPlugin {
 					});
 
 					parser.hooks.classExtendsExpression.tap(
-						"InnerGraphPlugin",
+						PLUGIN_NAME,
 						(expr, statement) => {
 							if (!InnerGraph.isEnabled(parser.state)) return;
 							if (parser.scope.topLevelScope === true) {
@@ -228,7 +256,9 @@ class InnerGraphPlugin {
 									fn &&
 									parser.isPure(
 										expr,
-										statement.id ? statement.id.range[1] : statement.range[0]
+										statement.id
+											? /** @type {Range} */ (statement.id.range)[1]
+											: /** @type {Range} */ (statement.range)[0]
 									)
 								) {
 									InnerGraph.setTopLevelSymbol(parser.state, fn);
@@ -239,7 +269,7 @@ class InnerGraphPlugin {
 					);
 
 					parser.hooks.classBodyElement.tap(
-						"InnerGraphPlugin",
+						PLUGIN_NAME,
 						(element, classDefinition) => {
 							if (!InnerGraph.isEnabled(parser.state)) return;
 							if (parser.scope.topLevelScope === true) {
@@ -252,7 +282,7 @@ class InnerGraphPlugin {
 					);
 
 					parser.hooks.classBodyValue.tap(
-						"InnerGraphPlugin",
+						PLUGIN_NAME,
 						(expression, element, classDefinition) => {
 							if (!InnerGraph.isEnabled(parser.state)) return;
 							if (parser.scope.topLevelScope === true) {
@@ -262,7 +292,9 @@ class InnerGraphPlugin {
 										!element.static ||
 										parser.isPure(
 											expression,
-											element.key ? element.key.range[1] : element.range[0]
+											element.key
+												? /** @type {Range} */ (element.key.range)[1]
+												: /** @type {Range} */ (element.range)[0]
 										)
 									) {
 										InnerGraph.setTopLevelSymbol(parser.state, fn);
@@ -274,9 +306,11 @@ class InnerGraphPlugin {
 														return;
 													default: {
 														const dep = new PureExpressionDependency(
-															expression.range
+															/** @type {Range} */ (expression.range)
 														);
-														dep.loc = expression.loc;
+														dep.loc =
+															/** @type {DependencyLocation} */
+															(expression.loc);
 														dep.usedByExports = usedByExports;
 														parser.state.module.addDependency(dep);
 														break;
@@ -292,7 +326,7 @@ class InnerGraphPlugin {
 						}
 					);
 
-					parser.hooks.declarator.tap("InnerGraphPlugin", (decl, statement) => {
+					parser.hooks.declarator.tap(PLUGIN_NAME, (decl, statement) => {
 						if (!InnerGraph.isEnabled(parser.state)) return;
 						const fn = declWithTopLevelSymbol.get(decl);
 
@@ -311,9 +345,9 @@ class InnerGraphPlugin {
 												return;
 											default: {
 												const dep = new PureExpressionDependency(
-													decl.init.range
+													/** @type {Range} */ (decl.init.range)
 												);
-												dep.loc = decl.loc;
+												dep.loc = /** @type {DependencyLocation} */ (decl.loc);
 												dep.usedByExports = usedByExports;
 												parser.state.module.addDependency(dep);
 												break;
@@ -325,12 +359,21 @@ class InnerGraphPlugin {
 							parser.walkExpression(decl.init);
 							InnerGraph.setTopLevelSymbol(parser.state, undefined);
 							return true;
+						} else if (
+							decl.id.type === "Identifier" &&
+							decl.init &&
+							decl.init.type === "ClassExpression" &&
+							classWithTopLevelSymbol.has(decl.init)
+						) {
+							parser.walkExpression(decl.init);
+							InnerGraph.setTopLevelSymbol(parser.state, undefined);
+							return true;
 						}
 					});
 
 					parser.hooks.expression
 						.for(topLevelSymbolTag)
-						.tap("InnerGraphPlugin", () => {
+						.tap(PLUGIN_NAME, () => {
 							const topLevelSymbol = /** @type {TopLevelSymbol} */ (
 								parser.currentTagData
 							);
@@ -343,21 +386,19 @@ class InnerGraphPlugin {
 								currentTopLevelSymbol || true
 							);
 						});
-					parser.hooks.assign
-						.for(topLevelSymbolTag)
-						.tap("InnerGraphPlugin", expr => {
-							if (!InnerGraph.isEnabled(parser.state)) return;
-							if (expr.operator === "=") return 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("javascript/auto")
-					.tap("InnerGraphPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, handler);
 				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("InnerGraphPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, handler);
 
-				compilation.hooks.finishModules.tap("InnerGraphPlugin", () => {
+				compilation.hooks.finishModules.tap(PLUGIN_NAME, () => {
 					logger.timeAggregateEnd("infer dependency usage");
 				});
 			}