webpack 5.111.0 → 5.112.0

package/lib/{ConcatenationScope.js → optimize/ConcatenationScope.js}

@@ -8,16 +8,16 @@
 const {
 	DEFAULT_EXPORT,
 	NAMESPACE_OBJECT_EXPORT
-} = require("./util/concatenate");
+} = require("../util/concatenate");
 
 /** @import { Source } from "webpack-sources" */
-/** @import Module from "./Module" */
+/** @import Module from "../module/Module" */
 /**
  * @import {
  * 	ConcatenatedModuleInfo,
  * 	ModuleInfo,
  * 	ExportName as Ids
- * } from "./optimize/ConcatenatedModule"
+ * } from "./ConcatenatedModule"
  */
 
 /** @typedef {{ start: number, end: number, name: string, leaked: boolean }} ModuleReferenceMatch */
@@ -39,6 +39,41 @@ const IDENTIFIER_CHARACTER_REGEXP = /[\w$]/;
 /** @type {WeakMap<Source, ModuleReferenceMatch[]>} */
 const moduleReferencesCache = new WeakMap();
 
+/**
+ * Hex encodings of the export paths a concatenation references, keyed by the
+ * module map every scope of that concatenation shares, so they die with it.
+ * @type {WeakMap<Map<Module, ModuleInfo>, { single: Map<string, string>, multi: Map<string, string> }>}
+ */
+const exportDataCache = new WeakMap();
+
+/**
+ * Hex-encodes one export path. A path is named by many references over one
+ * concatenation, so the encoding is cached rather than rebuilt per reference.
+ * @param {Map<Module, ModuleInfo>} modulesMap the scope's module map
+ * @param {string[]} ids the export path
+ * @returns {string} the hex encoding of the path
+ */
+const encodeExportData = (modulesMap, ids) => {
+	let caches = exportDataCache.get(modulesMap);
+	if (caches === undefined) {
+		caches = { single: new Map(), multi: new Map() };
+		exportDataCache.set(modulesMap, caches);
+	}
+	// a one-element path is keyed by the element itself, so the common case
+	// costs no key building; anything longer is keyed by its JSON
+	const single = ids.length === 1;
+	const cache = single ? caches.single : caches.multi;
+	const key = single ? ids[0] : JSON.stringify(ids);
+	const cached = cache.get(key);
+	if (cached !== undefined) return cached;
+	const encoded = Buffer.from(
+		single ? JSON.stringify(ids) : key,
+		"utf8"
+	).toString("hex");
+	cache.set(key, encoded);
+	return encoded;
+};
+
 /**
  * Encodes how a concatenated module reference should be interpreted when it is
  * later reconstructed from its placeholder identifier.
@@ -217,9 +252,7 @@ class ConcatenationScope {
 			: asiSafe === false
 				? "_asiSafe0"
 				: "";
-		const exportData = ids
-			? Buffer.from(JSON.stringify(ids), "utf8").toString("hex")
-			: "ns";
+		const exportData = ids ? encodeExportData(this._modulesMap, ids) : "ns";
 		// a "._" is appended to allow "delete ...", which would cause a SyntaxError in strict mode
 		return `__WEBPACK_MODULE_REFERENCE__${info.index}_${exportData}${callFlag}${directImportFlag}${deferredImportFlag}${mangleableNamespaceFlag}${moduleExportsAccessFlag}${asiSafeFlag}__._`;
 	}

package/lib/optimize/ConstExportsPlugin.js

@@ -5,14 +5,14 @@
 
 "use strict";
 
-const CircularModulesPlugin = require("../CircularModulesPlugin");
-const { UsageState } = require("../ExportsInfo");
+const { UsageState } = require("../graph/ExportsInfo");
+const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
+const { VariableInfoFlags } = require("../javascript/JavascriptParser");
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
 	JAVASCRIPT_MODULE_TYPE_ESM
-} = require("../ModuleTypeConstants");
-const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
-const { VariableInfoFlags } = require("../javascript/JavascriptParser");
+} = require("../module/ModuleTypeConstants");
+const CircularModulesPlugin = require("./CircularModulesPlugin");
 const {
 	InlinedUsedName,
 	enableInlineExports,
@@ -23,7 +23,7 @@ const { CircularKind } = CircularModulesPlugin;
 
 /** @import { InlinedValue } from "./InlineExports" */
 /** @import Compiler from "../Compiler" */
-/** @import ExportsInfo from "../ExportsInfo" */
+/** @import ExportsInfo from "../graph/ExportsInfo" */
 /** @import JavascriptParser from "../javascript/JavascriptParser" */
 /**
  * @import {
@@ -159,7 +159,7 @@ class ConstExportsPlugin {
 
 				if (!this.options.inlineExports) return;
 
-				// Lets HarmonyImportSpecifierDependency.getCondition skip the inline check
+				// Lets ESMImportSpecifierDependency.getCondition skip the inline check
 				// (and stay unconditional) when this plugin is not active
 				enableInlineExports(compilation.moduleGraph);
 

package/lib/optimize/EnsureChunkConditionsPlugin.js

@@ -5,10 +5,10 @@
 
 "use strict";
 
-const { STAGE_BASIC } = require("../OptimizationStages");
+const { STAGE_BASIC } = require("./OptimizationStages");
 
-/** @import Chunk from "../Chunk" */
-/** @import ChunkGroup from "../ChunkGroup" */
+/** @import Chunk from "../graph/Chunk" */
+/** @import ChunkGroup from "../graph/ChunkGroup" */
 /** @import Compiler from "../Compiler" */
 
 const PLUGIN_NAME = "EnsureChunkConditionsPlugin";

package/lib/{FlagAllModulesAsUsedPlugin.js → optimize/FlagAllModulesAsUsedPlugin.js}

@@ -5,10 +5,10 @@
 
 "use strict";
 
-const { getEntryRuntime, mergeRuntimeOwned } = require("./util/runtime");
+const { getEntryRuntime, mergeRuntimeOwned } = require("../util/runtime");
 
-/** @import Compiler from "./Compiler" */
-/** @import { RuntimeSpec } from "./util/runtime" */
+/** @import Compiler from "../Compiler" */
+/** @import { RuntimeSpec } from "../util/runtime" */
 
 const PLUGIN_NAME = "FlagAllModulesAsUsedPlugin";
 class FlagAllModulesAsUsedPlugin {

package/lib/{FlagDependencyExportsPlugin.js → optimize/FlagDependencyExportsPlugin.js}

@@ -5,24 +5,24 @@
 
 "use strict";
 
-const Queue = require("./util/Queue");
-const asyncLib = require("./util/async");
-const { compareModulesByIdentifier } = require("./util/comparators");
-const createHash = require("./util/createHash");
+const asyncLib = require("../util/async");
+const { compareModulesByIdentifier } = require("../util/comparators");
+const createHash = require("../util/createHash");
+const Queue = require("./Queue");
 
-/** @import Compiler from "./Compiler" */
-/** @import DependenciesBlock from "./DependenciesBlock" */
+/** @import Compiler from "../Compiler" */
+/** @import DependenciesBlock from "../graph/DependenciesBlock" */
 /**
  * @import Dependency, {
  * 	ExportSpec,
  * 	ExportsSpec,
  * 	ExportInfoName
- * } from "./Dependency"
+ * } from "../graph/Dependency"
  */
-/** @import ExportsInfo, { RestoreProvidedData } from "./ExportsInfo" */
-/** @import { HashFunction } from "../declarations/WebpackOptions" */
-/** @import LazyBarrelController from "./LazyBarrel" */
-/** @import Module, { BuildInfo } from "./Module" */
+/** @import ExportsInfo, { RestoreProvidedData } from "../graph/ExportsInfo" */
+/** @import { HashFunction } from "../../declarations/WebpackOptions" */
+/** @import LazyBarrels from "./LazyBarrels" */
+/** @import Module, { BuildInfo } from "../module/Module" */
 
 const PLUGIN_NAME = "FlagDependencyExportsPlugin";
 const PLUGIN_LOGGER_NAME = `webpack.${PLUGIN_NAME}`;
@@ -33,12 +33,12 @@ const PLUGIN_LOGGER_NAME = `webpack.${PLUGIN_NAME}`;
  * Cache key fragment for what changes provided exports without changing the
  * module's source: still-lazy barrel requests and DefinePlugin value versions.
  * @param {Module} module the module
- * @param {LazyBarrelController} lazyBarrelController the compilation's lazy barrel controller
+ * @param {LazyBarrels} lazyBarrels the compilation's lazy barrels
  * @param {HashFunction} hashFunction hash function for long keys
  * @returns {string} etag for provided-exports mem/persistent cache, "" when neither applies
  */
-const getProvidedExportsEtag = (module, lazyBarrelController, hashFunction) => {
-	const lazyRequests = lazyBarrelController.getLazyRequests(module);
+const getProvidedExportsEtag = (module, lazyBarrels, hashFunction) => {
+	const lazyRequests = lazyBarrels.getLazyRequests(module);
 	const buildInfo = /** @type {BuildInfo | undefined} */ (module.buildInfo);
 	const valueDependencies = buildInfo && buildInfo.valueDependencies;
 	const hasValueDependencies =
@@ -80,7 +80,7 @@ class FlagDependencyExportsPlugin {
 		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			const moduleGraph = compilation.moduleGraph;
 			const cache = compilation.getCache(PLUGIN_NAME);
-			const lazyBarrelController = compilation._lazyBarrelController;
+			const lazyBarrels = compilation._lazyBarrels;
 			const hashFunction = compilation.outputOptions.hashFunction;
 			compilation.hooks.finishModules.tapAsync(
 				PLUGIN_NAME,
@@ -134,13 +134,12 @@ class FlagDependencyExportsPlugin {
 							const memCacheEntry = memCache && memCache.get(this);
 							const etag = getProvidedExportsEtag(
 								module,
-								lazyBarrelController,
+								lazyBarrels,
 								hashFunction
 							);
 							// validated by the still-lazy request keys: reference-change
-							// detection cannot invalidate the mem cache when the un-lazied
-							// connections are unsafe-cached (they are skipped when comparing
-							// references)
+							// detection cannot invalidate the mem cache while the un-lazied
+							// connections are unsafe-cached, being skipped in the comparison
 							if (memCacheEntry !== undefined && memCacheEntry.etag === etag) {
 								statRestoredFromMemCache++;
 								exportsInfo.restoreProvided(memCacheEntry.data);
@@ -172,16 +171,12 @@ class FlagDependencyExportsPlugin {
 							logger.timeEnd("restore cached provided exports");
 							if (err) return callback(err);
 
-							// Seed the queue with targets before the modules that read
-							// them. Enqueueing at the two branches above ordered the work by
-							// how fast each cache lookup answered — one is synchronous, the
-							// other a `cache.get` callback — so the persistent cache decided
-							// it. A module analysed before the module it re-exports from
-							// reads exports that are not determined yet and over-estimates,
-							// and this loop can add exports info but never retract it, so
-							// the over-estimate survives the pass that corrects it. The
-							// roots are sorted so the walk is stable, and post-order visits
-							// each module after everything it points at.
+							// WHY: enqueueing at the branches above ordered the work by how
+							// fast each cache lookup answered, letting the persistent cache
+							// decide it. A module analyzed before the one it re-exports from
+							// over-estimates its exports, and this loop can add exports info
+							// but never retract it, so that over-estimate would survive. Sorted
+							// roots and post-order visit each module after what it points at.
 							/** @type {Set<Module>} */
 							const visited = new Set();
 							/** @type {Module[]} */
@@ -539,7 +534,7 @@ class FlagDependencyExportsPlugin {
 										moduleMemCaches && moduleMemCaches.get(module);
 									const etag = getProvidedExportsEtag(
 										module,
-										lazyBarrelController,
+										lazyBarrels,
 										hashFunction
 									);
 									if (memCache) {

package/lib/{FlagDependencyUsagePlugin.js → optimize/FlagDependencyUsagePlugin.js}

@@ -5,21 +5,21 @@
 
 "use strict";
 
-const Dependency = require("./Dependency");
-const { UsageState } = require("./ExportsInfo");
-const ModuleGraphConnection = require("./ModuleGraphConnection");
+const Dependency = require("../graph/Dependency");
+const { UsageState } = require("../graph/ExportsInfo");
+const ModuleGraphConnection = require("../graph/ModuleGraphConnection");
+const ArrayQueue = require("../util/ArrayQueue");
+const TupleSet = require("../util/TupleSet");
+const { getEntryRuntime, mergeRuntimeOwned } = require("../util/runtime");
 const { STAGE_DEFAULT } = require("./OptimizationStages");
-const ArrayQueue = require("./util/ArrayQueue");
-const TupleQueue = require("./util/TupleQueue");
-const TupleSet = require("./util/TupleSet");
-const { getEntryRuntime, mergeRuntimeOwned } = require("./util/runtime");
+const TupleQueue = require("./TupleQueue");
 
-/** @import Compiler from "./Compiler" */
-/** @import DependenciesBlock from "./DependenciesBlock" */
-/** @import { ReferencedExport, ReferencedExports } from "./Dependency" */
-/** @import ExportsInfo from "./ExportsInfo" */
-/** @import Module from "./Module" */
-/** @import { RuntimeSpec } from "./util/runtime" */
+/** @import Compiler from "../Compiler" */
+/** @import DependenciesBlock from "../graph/DependenciesBlock" */
+/** @import { ReferencedExport, ReferencedExports } from "../graph/Dependency" */
+/** @import ExportsInfo from "../graph/ExportsInfo" */
+/** @import Module from "../module/Module" */
+/** @import { RuntimeSpec } from "../util/runtime" */
 
 const {
 	NO_EXPORTS_REFERENCED,
@@ -33,12 +33,12 @@ const PLUGIN_LOGGER_NAME = `webpack.${PLUGIN_NAME}`;
 // Hoisted stateless predicates for setUsedConditionally on the innermost
 // used-export loop, so they aren't re-allocated per export.
 /**
- * @param {import("./ExportsInfo").UsageStateType} used usage state
+ * @param {import("../graph/ExportsInfo").UsageStateType} used usage state
  * @returns {boolean} whether unused
  */
 const IS_UNUSED = (used) => used === UsageState.Unused;
 /**
- * @param {import("./ExportsInfo").UsageStateType} used usage state
+ * @param {import("../graph/ExportsInfo").UsageStateType} used usage state
  * @returns {boolean} whether not used
  */
 const IS_NOT_USED = (used) => used !== UsageState.Used;
@@ -77,10 +77,10 @@ class FlagDependencyUsagePlugin {
 					/** @type {Map<ExportsInfo, Module>} */
 					const exportInfoToModuleMap = new Map();
 
-					/** @type {TupleQueue<Module, RuntimeSpec>} */
+					/** @type {TupleQueue<[Module], RuntimeSpec>} */
 					const queue = new TupleQueue();
 
-					/** @type {TupleSet<Module, RuntimeSpec> | undefined} */
+					/** @type {TupleSet<[Module], RuntimeSpec> | undefined} */
 					let walkedSideEffectFreeModules;
 
 					/**
@@ -93,10 +93,9 @@ class FlagDependencyUsagePlugin {
 					const processReferencedModule = (module, usedExports, runtime) => {
 						const exportsInfo = moduleGraph.getExportsInfo(module);
 						if (usedExports === EXPORTS_OBJECT_REFERENCED_MANGLEABLE) {
-							// The whole namespace object escapes via a reference that codegen
-							// can materialize as a decoupled namespace object. When all exports
-							// are statically known we keep them mangleable instead of marking
-							// them used-in-unknown-way.
+							// The namespace object escapes through a reference codegen can
+							// materialize, so with every export statically known they stay
+							// mangleable rather than used-in-unknown-way.
 							if (
 								this.mangleEscapingNamespaces &&
 								module.buildMeta &&
@@ -237,10 +236,9 @@ class FlagDependencyUsagePlugin {
 						/** @typedef {Map<string, string[] | ReferencedExport>} ExportMaps */
 						/** @type {Map<Module, ReferencedExports | ExportMaps>} */
 						const map = new Map();
-						// Modules whose whole namespace object escapes in a mangleable way.
-						// Tracked separately so specific member references are still merged
-						// (and marked used) instead of being dropped by the escape marker.
-						// Lazily allocated — usually empty.
+						// Modules whose whole namespace escapes but stays mangleable, kept
+						// apart so specific member references are still merged and marked
+						// used rather than dropped by the escape marker. Usually empty.
 						/** @type {Set<Module> | undefined} */
 						let mangleableEscapeModules;
 
@@ -289,11 +287,9 @@ class FlagDependencyUsagePlugin {
 									}
 									continue;
 								}
-								// A mangleable whole-object escape keeps the module's exports
-								// mangleable (applied after the merge). Unlike the conservative
-								// marker it must not drop specific member references: those still
-								// need their own (possibly non-existent) export marked used so
-								// they render as a qualified access, not a bare `undefined`.
+								// A mangleable escape keeps the exports mangleable, applied after
+								// the merge. It must not drop specific member references: each
+								// still needs marking, or it renders as a bare `undefined`.
 								if (
 									referencedExports === EXPORTS_OBJECT_REFERENCED_MANGLEABLE
 								) {

package/lib/{FlagEntryExportAsUsedPlugin.js → optimize/FlagEntryExportAsUsedPlugin.js}

@@ -5,9 +5,9 @@
 
 "use strict";
 
-const { getEntryRuntime } = require("./util/runtime");
+const { getEntryRuntime } = require("../util/runtime");
 
-/** @import Compiler from "./Compiler" */
+/** @import Compiler from "../Compiler" */
 
 const PLUGIN_NAME = "FlagEntryExportAsUsedPlugin";
 

package/lib/optimize/FlagIncludedChunksPlugin.js

@@ -7,9 +7,9 @@
 
 const { compareIds } = require("../util/comparators");
 
-/** @import Chunk, { ChunkId } from "../Chunk" */
+/** @import Chunk, { ChunkId } from "../graph/Chunk" */
 /** @import Compiler from "../Compiler" */
-/** @import Module from "../Module" */
+/** @import Module from "../module/Module" */
 
 const PLUGIN_NAME = "FlagIncludedChunksPlugin";
 
@@ -24,17 +24,9 @@ class FlagIncludedChunksPlugin {
 			compilation.hooks.optimizeChunkIds.tap(PLUGIN_NAME, (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)
+				// Two bit integers per module, within v8's 2^31 SMI range. The bits are
+				// spread so 2^31 falls to about one module in `modulesCount` and 2^0 to
+				// any module missing a better one, which gives the modulo below.
 				/** @type {WeakMap<Module, number>} */
 				const moduleBits = new WeakMap();
 				const modulesCount = compilation.modules.size;

package/lib/optimize/InlineExports.js

@@ -14,8 +14,8 @@ const { propertyAccess } = require("../util/property");
  * 	ObjectSerializerContext
  * } from "../serialization/ObjectMiddleware"
  */
-/** @import ModuleGraph from "../ModuleGraph" */
-/** @import Module from "../Module" */
+/** @import ModuleGraph from "../graph/ModuleGraph" */
+/** @import Module from "../module/Module" */
 /** @import { RuntimeSpec } from "../util/runtime" */
 /** @import Hash from "../util/Hash" */
 
@@ -172,7 +172,7 @@ const isInlineExportsEnabled = (moduleGraph) =>
 const isInlineEnabled = (module) =>
 	Boolean(
 		module.buildInfo &&
-		/** @type {import("../Module").BuildInfo} */
+		/** @type {import("../module/Module").BuildInfo} */
 		(module.buildInfo).inlineExports
 	);
 
@@ -190,11 +190,19 @@ const isExportInlined = (moduleGraph, module, ids, runtime) => {
 	return moduleGraph.getExportsInfo(module).hasInlinedUsedName(ids, runtime);
 };
 
+/**
+ * Whether a used name is an inlined value rather than a property name.
+ * @param {unknown} value a used name
+ * @returns {value is InlinedUsedName} true when the value is inlined
+ */
+const isInlinedUsedName = (value) => value instanceof InlinedUsedName;
+
 module.exports.InlinedUsedName = InlinedUsedName;
 module.exports.InlinedValue = InlinedValue;
 module.exports.MAX_INLINE_BYTES = MAX_INLINE_BYTES;
 module.exports.enableInlineExports = enableInlineExports;
 module.exports.isExportInlined = isExportInlined;
 module.exports.isInlineEnabled = isInlineEnabled;
+module.exports.isInlinedUsedName = isInlinedUsedName;
 module.exports.isInlineExportsEnabled = isInlineExportsEnabled;
 module.exports.toInlinedValue = toInlinedValue;

package/lib/optimize/InnerGraph.js

@@ -5,14 +5,14 @@
 
 "use strict";
 
-const { UsageState } = require("../ExportsInfo");
+const { UsageState } = require("../graph/ExportsInfo");
 const JavascriptParser = require("../javascript/JavascriptParser");
 
 /** @import Compilation from "../Compilation" */
-/** @import Dependency, { GetConditionFn } from "../Dependency" */
-/** @import Module from "../Module" */
-/** @import ModuleGraph from "../ModuleGraph" */
-/** @import { ParserState } from "../Parser" */
+/** @import Dependency, { GetConditionFn } from "../graph/Dependency" */
+/** @import Module from "../module/Module" */
+/** @import ModuleGraph from "../graph/ModuleGraph" */
+/** @import { ParserState } from "../module/Parser" */
 /** @import { RuntimeSpec } from "../util/runtime" */
 
 /** @typedef {boolean | ((compilation: Compilation, module: Module) => boolean)} PureCondition */
@@ -485,12 +485,4 @@ module.exports.getInnerGraphUtils = (compilation) => {
 	return utils;
 };
 
-/**
- * Usage callback map.
- * @param {Dependency} dependency the dependency
- * @param {UsedByExports | undefined} usedByExports usedByExports info
- * @param {ModuleGraph} moduleGraph moduleGraph
- * @returns {null | false | GetConditionFn} function to determine if the connection is active
- */
-
 module.exports.topLevelSymbolTag = topLevelSymbolTag;

package/lib/optimize/InnerGraphPlugin.js

@@ -5,17 +5,17 @@
 
 "use strict";
 
+const {
+	harmonySpecifierTag
+} = require("../dependencies/esm/ESMImportDependencyParserPlugin");
+const isDependencyKind = require("../graph/isDependencyKind");
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
 	JAVASCRIPT_MODULE_TYPE_ESM
-} = require("../ModuleTypeConstants");
-const RuntimeGlobals = require("../RuntimeGlobals");
-const {
-	harmonySpecifierTag
-} = require("../dependencies/HarmonyImportDependencyParserPlugin");
-const HarmonyImportSideEffectDependency = require("../dependencies/HarmonyImportSideEffectDependency");
-const PureExpressionDependency = require("../dependencies/PureExpressionDependency");
+} = require("../module/ModuleTypeConstants");
+const RuntimeGlobals = require("../runtime/RuntimeGlobals");
 const { getInnerGraphUtils, topLevelSymbolTag } = require("./InnerGraph");
+const PureExpressionDependency = require("./PureExpressionDependency");
 
 /**
  * @import {
@@ -36,8 +36,8 @@ const { getInnerGraphUtils, topLevelSymbolTag } = require("./InnerGraph");
  */
 /** @import Compilation from "../Compilation" */
 /** @import Compiler from "../Compiler" */
-/** @import Dependency from "../Dependency" */
-/** @import Module from "../Module" */
+/** @import Dependency from "../graph/Dependency" */
+/** @import Module from "../module/Module" */
 /** @import JavascriptParser, { Range } from "../javascript/JavascriptParser" */
 /** @import { TopLevelSymbol } from "./InnerGraph" */
 
@@ -122,10 +122,8 @@ class InnerGraphPlugin {
 					// 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 = ...)
+					// Three kinds of node carry a symbol: a full statement, a class, and a
+					// variable declarator.
 
 					/** @type {WeakMap<Node | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration, TopLevelSymbol>} */
 					let statementWithTopLevelSymbol = new WeakMap();
@@ -187,7 +185,7 @@ class InnerGraphPlugin {
 								const moduleGraph = compilation.moduleGraph;
 								for (const dep of module.dependencies) {
 									if (
-										dep instanceof HarmonyImportSideEffectDependency &&
+										isDependencyKind(dep, "esm-side-effect-import") &&
 										dep.request === source
 									) {
 										const m = moduleGraph.getModule(dep);
@@ -360,16 +358,12 @@ class InnerGraphPlugin {
 					// 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
+					// A `PureExpressionDependency` is sometimes added too, so a pure
+					// expression is skipped even where minimizing leaves it: the symbols it
+					// uses may have been 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.
+					// A reference registers a dependency from the symbol in state to the one
+					// referenced, which is how the graph of all of them is built.
 
 					// The following hooks are called during walking: