webpack 5.109.0 → 5.109.1

package/bin/webpack.js

@@ -2,6 +2,18 @@
 
 "use strict";
 
+// Cache compiled module bytecode on disk (available since Node.js 22.8)
+// eslint-disable-next-line n/no-unsupported-features/node-builtins
+const { enableCompileCache } = require("module");
+
+if (enableCompileCache) {
+	try {
+		enableCompileCache();
+	} catch (_error) {
+		// Nothing
+	}
+}
+
 /**
  * @param {string} command process to run
  * @param {string[]} args command line arguments

package/lib/ChunkGraph.js

@@ -52,6 +52,19 @@ const EMPTY_SET = new Set();
 
 const ZERO_BIG_INT = BigInt(0);
 
+/**
+ * Active state to string. Module-level (depends only on ModuleGraphConnection)
+ * so it isn't re-allocated on every getModuleGraphHash call, incl. cache hits.
+ * @param {ConnectionState} state state
+ * @returns {"F" | "T" | "O"} result
+ */
+const activeStateToString = (state) => {
+	if (state === false) return "F";
+	if (state === true) return "T";
+	if (state === ModuleGraphConnection.TRANSITIVE_ONLY) return "O";
+	throw new Error("Not implemented active state");
+};
+
 const compareModuleIterables = compareIterables(compareModulesByIdentifier);
 
 /** @typedef {(c: Chunk, chunkGraph: ChunkGraph) => boolean} ChunkFilterPredicate */
@@ -1821,22 +1834,11 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 			cgm.graphHashesWithConnections = new RuntimeSpecMap();
 		}
 
-		/**
-		 * Active state to string.
-		 * @param {ConnectionState} state state
-		 * @returns {"F" | "T" | "O"} result
-		 */
-		const activeStateToString = (state) => {
-			if (state === false) return "F";
-			if (state === true) return "T";
-			if (state === ModuleGraphConnection.TRANSITIVE_ONLY) return "O";
-			throw new Error("Not implemented active state");
-		};
-		const strict =
-			module.buildMeta &&
-			/** @type {JavascriptModuleBuildMeta} */ (module.buildMeta)
-				.strictHarmonyModule;
 		return cgm.graphHashesWithConnections.provide(runtime, () => {
+			const strict =
+				module.buildMeta &&
+				/** @type {JavascriptModuleBuildMeta} */ (module.buildMeta)
+					.strictHarmonyModule;
 			const graphHash = this._getModuleGraphHashBigInt(
 				cgm,
 				module,

package/lib/CompatibilityPlugin.js

@@ -181,6 +181,37 @@ class CompatibilityPlugin {
 							});
 							return true;
 						});
+					// `const`/`let` are block-pre-walked, by which point the name is no
+					// longer free and `hooks.pattern` is not dispatched for it — tag
+					// them through the kind-specific declaration hooks instead.
+					// Returning nothing lets the variable be defined, keeping the tag.
+					for (const hookMap of [
+						parser.hooks.varDeclarationConst,
+						parser.hooks.varDeclarationLet
+					]) {
+						hookMap.for(RuntimeGlobals.require).tap(PLUGIN_NAME, (ident) => {
+							parser.tagVariable(ident.name, nestedWebpackIdentifierTag, {
+								name: `__nested_webpack_require_${
+									/** @type {Range} */ (ident.range)[0]
+								}__`,
+								declaration: {
+									updated: false,
+									loc: parser.getLocation(ident),
+									range: /** @type {Range} */ (ident.range)
+								}
+							});
+						});
+						hookMap.for(RuntimeGlobals.exports).tap(PLUGIN_NAME, (ident) => {
+							parser.tagVariable(ident.name, nestedWebpackIdentifierTag, {
+								name: "__nested_webpack_exports__",
+								declaration: {
+									updated: false,
+									loc: parser.getLocation(ident),
+									range: /** @type {Range} */ (ident.range)
+								}
+							});
+						});
+					}
 					// Update single `var __webpack_require__ = {};` and `var __webpack_exports__ = {};` without expression
 					parser.hooks.declarator.tap(PLUGIN_NAME, (declarator) => {
 						if (

package/lib/Compilation.js

@@ -3504,6 +3504,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			this.addModuleQueue.clear();
 			// lazy barrel only acts during make; release its bookkeeping now
 			this._lazyBarrelController.clear();
+			// unsafe-cache restore tables are only read during make; release them
+			// so they stop pinning restored modules for the rest of the compilation
+			this._restoredUnsafeCacheModuleEntries.clear();
+			this._restoredUnsafeCacheEntries.clear();
 			return callback(err);
 		};
 
@@ -4754,10 +4758,13 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		for (const module of this.modules) {
 			const memCache = moduleMemCaches2 && moduleMemCaches2.get(module);
 			for (const runtime of chunkGraph.getModuleRuntimes(module)) {
+				const cacheKey = memCache
+					? `moduleHash-${getRuntimeKey(runtime)}`
+					: undefined;
 				if (memCache) {
 					const digest =
 						/** @type {string} */
-						(memCache.get(`moduleHash-${getRuntimeKey(runtime)}`));
+						(memCache.get(/** @type {string} */ (cacheKey)));
 					if (digest !== undefined) {
 						chunkGraph.setModuleHashes(
 							module,
@@ -4781,7 +4788,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					errors
 				);
 				if (memCache) {
-					memCache.set(`moduleHash-${getRuntimeKey(runtime)}`, digest);
+					memCache.set(/** @type {string} */ (cacheKey), digest);
 				}
 			}
 		}

package/lib/DefinePlugin.js

@@ -628,6 +628,26 @@ const getRuntimeRequirements = (code) => {
 		: [RuntimeGlobals.requireScope];
 };
 
+/**
+ * Prefixes an evaluation error with the offending define key so a bare
+ * "Unexpected token" becomes actionable. The original error is mutated and
+ * returned (not re-wrapped) so its `loc`/`stack` survive for ModuleParseError's
+ * code frame instead of being dumped into the message.
+ * @param {string} key the defined key
+ * @param {CodeValue} code the defined value
+ * @param {unknown} error the original evaluation error
+ * @returns {Error} the annotated error
+ */
+const annotateEvaluationError = (key, code, error) => {
+	const value = typeof code === "string" ? code : JSON.stringify(code);
+	const prefix = `DefinePlugin: failed to evaluate value for "${key}" (\`${value}\`)`;
+	if (error instanceof Error) {
+		error.message = `${prefix}: ${error.message}`;
+		return error;
+	}
+	return new WebpackError(`${prefix}: ${error}`);
+};
+
 /**
  * Defines the define plugin hooks type used by this module.
  * @typedef {object} DefinePluginHooks
@@ -954,17 +974,23 @@ class DefinePlugin {
 						});
 						parser.hooks.typeof.for(key).tap(PLUGIN_NAME, (expr) => {
 							addValueDependency(originalKey);
-							const codeCode = toCode(
-								code,
-								parser,
-								compilation.valueCacheVersions,
-								originalKey,
-								runtimeTemplate,
-								logger,
-								null
-							);
-							const typeofCode = isTypeof ? codeCode : `typeof (${codeCode})`;
-							const res = parser.evaluate(typeofCode);
+							/** @type {BasicEvaluatedExpression} */
+							let res;
+							try {
+								const codeCode = toCode(
+									code,
+									parser,
+									compilation.valueCacheVersions,
+									originalKey,
+									runtimeTemplate,
+									logger,
+									null
+								);
+								const typeofCode = isTypeof ? codeCode : `typeof (${codeCode})`;
+								res = parser.evaluate(typeofCode);
+							} catch (err) {
+								throw annotateEvaluationError(originalKey, code, err);
+							}
 							if (!res.isString()) return;
 							return toConstantDependency(
 								parser,

package/lib/ExportsInfo.js

@@ -66,6 +66,11 @@ const UsageState = Object.freeze({
 
 const RETURNS_TRUE = () => true;
 
+// Shared empty visited-set for `findTarget`: `_findTarget` only reads
+// `alreadyVisited` (`.has`), never mutates it, so a fresh `new Set()` per call
+// is pure churn on the per-export reexport hot path. Must stay never-mutated.
+const EMPTY_VISITED = /** @type {Set<ExportInfo>} */ (new Set());
+
 const CIRCULAR = Symbol("circular target");
 
 // bit layout of ExportInfo._inlineFlags
@@ -1399,12 +1404,16 @@ class ExportInfo {
 	 * @returns {boolean} true, if something has changed
 	 */
 	setTarget(key, connection, exportName, priority = 0) {
-		if (exportName) exportName = [...exportName];
+		// `equals` compares element-wise, so the incoming `exportName` can be used
+		// directly for the change-check; only copy it when actually stored, so the
+		// common no-op (unchanged target) path allocates nothing.
 		if (!this._target) {
 			this._target = /** @type {Target} */ (new Map());
 			this._target.set(key, {
 				connection,
-				export: /** @type {ExportInfoName[]} */ (exportName),
+				export: /** @type {ExportInfoName[]} */ (
+					exportName ? [...exportName] : exportName
+				),
 				priority
 			});
 			return true;
@@ -1414,7 +1423,9 @@ class ExportInfo {
 			if (oldTarget === null && !connection) return false;
 			this._target.set(key, {
 				connection,
-				export: /** @type {ExportInfoName[]} */ (exportName),
+				export: /** @type {ExportInfoName[]} */ (
+					exportName ? [...exportName] : exportName
+				),
 				priority
 			});
 			this._maxTarget = undefined;
@@ -1428,7 +1439,9 @@ class ExportInfo {
 				: oldTarget.export)
 		) {
 			oldTarget.connection = connection;
-			oldTarget.export = /** @type {ExportInfoName[]} */ (exportName);
+			oldTarget.export = /** @type {ExportInfoName[]} */ (
+				exportName ? [...exportName] : exportName
+			);
 			oldTarget.priority = priority;
 			this._maxTarget = undefined;
 			return true;
@@ -1578,7 +1591,11 @@ class ExportInfo {
 	 * @returns {TargetItemWithoutConnection | null | undefined | false} the target, undefined when there is no target, false when no target is valid
 	 */
 	findTarget(moduleGraph, validTargetModuleFilter) {
-		return this._findTarget(moduleGraph, validTargetModuleFilter, new Set());
+		return this._findTarget(
+			moduleGraph,
+			validTargetModuleFilter,
+			EMPTY_VISITED
+		);
 	}
 
 	/**

package/lib/FileSystemInfo.js

@@ -297,6 +297,22 @@ class SnapshotIterable {
 /** @typedef {Set<string>} ManagedMissing */
 /** @typedef {Set<Snapshot>} Children */
 
+// `Snapshot._flags` bit for each optional field. Serialized as a whole integer,
+// so these values are a persisted-cache format contract — never renumber them.
+const SNAPSHOT_FLAG_START_TIME = 1;
+const SNAPSHOT_FLAG_FILE_TIMESTAMPS = 2;
+const SNAPSHOT_FLAG_FILE_HASHES = 4;
+const SNAPSHOT_FLAG_FILE_TSHS = 8;
+const SNAPSHOT_FLAG_CONTEXT_TIMESTAMPS = 0x10;
+const SNAPSHOT_FLAG_CONTEXT_HASHES = 0x20;
+const SNAPSHOT_FLAG_CONTEXT_TSHS = 0x40;
+const SNAPSHOT_FLAG_MISSING_EXISTENCE = 0x80;
+const SNAPSHOT_FLAG_MANAGED_ITEM_INFO = 0x100;
+const SNAPSHOT_FLAG_MANAGED_FILES = 0x200;
+const SNAPSHOT_FLAG_MANAGED_CONTEXTS = 0x400;
+const SNAPSHOT_FLAG_MANAGED_MISSING = 0x800;
+const SNAPSHOT_FLAG_CHILDREN = 0x1000;
+
 class Snapshot {
 	constructor() {
 		/** @type {number} */
@@ -336,7 +352,7 @@ class Snapshot {
 	}
 
 	hasStartTime() {
-		return (this._flags & 1) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_START_TIME) !== 0;
 	}
 
 	/**
@@ -344,7 +360,7 @@ class Snapshot {
 	 * @param {number} value start value
 	 */
 	setStartTime(value) {
-		this._flags |= 1;
+		this._flags |= SNAPSHOT_FLAG_START_TIME;
 		this.startTime = value;
 	}
 
@@ -375,7 +391,7 @@ class Snapshot {
 	}
 
 	hasFileTimestamps() {
-		return (this._flags & 2) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_FILE_TIMESTAMPS) !== 0;
 	}
 
 	/**
@@ -383,12 +399,12 @@ class Snapshot {
 	 * @param {FileTimestamps} value file timestamps
 	 */
 	setFileTimestamps(value) {
-		this._flags |= 2;
+		this._flags |= SNAPSHOT_FLAG_FILE_TIMESTAMPS;
 		this.fileTimestamps = value;
 	}
 
 	hasFileHashes() {
-		return (this._flags & 4) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_FILE_HASHES) !== 0;
 	}
 
 	/**
@@ -396,12 +412,12 @@ class Snapshot {
 	 * @param {FileHashes} value file hashes
 	 */
 	setFileHashes(value) {
-		this._flags |= 4;
+		this._flags |= SNAPSHOT_FLAG_FILE_HASHES;
 		this.fileHashes = value;
 	}
 
 	hasFileTshs() {
-		return (this._flags & 8) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_FILE_TSHS) !== 0;
 	}
 
 	/**
@@ -409,12 +425,12 @@ class Snapshot {
 	 * @param {FileTshs} value file tshs
 	 */
 	setFileTshs(value) {
-		this._flags |= 8;
+		this._flags |= SNAPSHOT_FLAG_FILE_TSHS;
 		this.fileTshs = value;
 	}
 
 	hasContextTimestamps() {
-		return (this._flags & 0x10) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_CONTEXT_TIMESTAMPS) !== 0;
 	}
 
 	/**
@@ -422,12 +438,12 @@ class Snapshot {
 	 * @param {ContextTimestamps} value context timestamps
 	 */
 	setContextTimestamps(value) {
-		this._flags |= 0x10;
+		this._flags |= SNAPSHOT_FLAG_CONTEXT_TIMESTAMPS;
 		this.contextTimestamps = value;
 	}
 
 	hasContextHashes() {
-		return (this._flags & 0x20) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_CONTEXT_HASHES) !== 0;
 	}
 
 	/**
@@ -435,12 +451,12 @@ class Snapshot {
 	 * @param {ContextHashes} value context hashes
 	 */
 	setContextHashes(value) {
-		this._flags |= 0x20;
+		this._flags |= SNAPSHOT_FLAG_CONTEXT_HASHES;
 		this.contextHashes = value;
 	}
 
 	hasContextTshs() {
-		return (this._flags & 0x40) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_CONTEXT_TSHS) !== 0;
 	}
 
 	/**
@@ -448,12 +464,12 @@ class Snapshot {
 	 * @param {ContextTshs} value context tshs
 	 */
 	setContextTshs(value) {
-		this._flags |= 0x40;
+		this._flags |= SNAPSHOT_FLAG_CONTEXT_TSHS;
 		this.contextTshs = value;
 	}
 
 	hasMissingExistence() {
-		return (this._flags & 0x80) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_MISSING_EXISTENCE) !== 0;
 	}
 
 	/**
@@ -461,12 +477,12 @@ class Snapshot {
 	 * @param {MissingExistence} value context tshs
 	 */
 	setMissingExistence(value) {
-		this._flags |= 0x80;
+		this._flags |= SNAPSHOT_FLAG_MISSING_EXISTENCE;
 		this.missingExistence = value;
 	}
 
 	hasManagedItemInfo() {
-		return (this._flags & 0x100) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_MANAGED_ITEM_INFO) !== 0;
 	}
 
 	/**
@@ -474,12 +490,12 @@ class Snapshot {
 	 * @param {ManagedItemInfo} value managed item info
 	 */
 	setManagedItemInfo(value) {
-		this._flags |= 0x100;
+		this._flags |= SNAPSHOT_FLAG_MANAGED_ITEM_INFO;
 		this.managedItemInfo = value;
 	}
 
 	hasManagedFiles() {
-		return (this._flags & 0x200) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_MANAGED_FILES) !== 0;
 	}
 
 	/**
@@ -487,12 +503,12 @@ class Snapshot {
 	 * @param {ManagedFiles} value managed files
 	 */
 	setManagedFiles(value) {
-		this._flags |= 0x200;
+		this._flags |= SNAPSHOT_FLAG_MANAGED_FILES;
 		this.managedFiles = value;
 	}
 
 	hasManagedContexts() {
-		return (this._flags & 0x400) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_MANAGED_CONTEXTS) !== 0;
 	}
 
 	/**
@@ -500,12 +516,12 @@ class Snapshot {
 	 * @param {ManagedContexts} value managed contexts
 	 */
 	setManagedContexts(value) {
-		this._flags |= 0x400;
+		this._flags |= SNAPSHOT_FLAG_MANAGED_CONTEXTS;
 		this.managedContexts = value;
 	}
 
 	hasManagedMissing() {
-		return (this._flags & 0x800) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_MANAGED_MISSING) !== 0;
 	}
 
 	/**
@@ -513,12 +529,12 @@ class Snapshot {
 	 * @param {ManagedMissing} value managed missing
 	 */
 	setManagedMissing(value) {
-		this._flags |= 0x800;
+		this._flags |= SNAPSHOT_FLAG_MANAGED_MISSING;
 		this.managedMissing = value;
 	}
 
 	hasChildren() {
-		return (this._flags & 0x1000) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_CHILDREN) !== 0;
 	}
 
 	/**
@@ -526,7 +542,7 @@ class Snapshot {
 	 * @param {Children} value children
 	 */
 	setChildren(value) {
-		this._flags |= 0x1000;
+		this._flags |= SNAPSHOT_FLAG_CHILDREN;
 		this.children = value;
 	}
 
@@ -1221,6 +1237,58 @@ const addAll = (source, target) => {
 
 const getEsModuleLexer = memoize(() => require("es-module-lexer"));
 
+const getAcorn = memoize(/* istanbul ignore next */ () => require("acorn"));
+
+// Bun doesn't populate `require.cache` `module.children`, so the CJS build-dependency
+// walk needs a source-parsing fallback there. Node/Deno populate it — never pay for it.
+const IS_BUN = Boolean(process.versions.bun);
+
+/**
+ * Collects static `require("literal")` specifiers from CommonJS source. Used as a
+ * fallback where `require.cache` children aren't populated (e.g. Bun), so build
+ * dependencies of a CJS file are still tracked. Dynamic requires can't be seen here.
+ * @param {string} source source
+ * @returns {Set<string>} required specifiers
+ */
+// Bun-only: exercised by BuildDependencies.longtest under the Bun CI job (no coverage upload).
+/* istanbul ignore next */
+const parseCjsRequires = (source) => {
+	/** @type {Set<string>} */
+	const requires = new Set();
+	const ast = getAcorn().parse(source, {
+		ecmaVersion: "latest",
+		sourceType: "script",
+		allowReturnOutsideFunction: true
+	});
+	/** @type {EXPECTED_ANY[]} */
+	const stack = [ast];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		if (!node || typeof node.type !== "string") continue;
+		if (
+			node.type === "CallExpression" &&
+			node.callee.type === "Identifier" &&
+			node.callee.name === "require" &&
+			node.arguments.length === 1 &&
+			node.arguments[0].type === "Literal" &&
+			typeof node.arguments[0].value === "string"
+		) {
+			requires.add(node.arguments[0].value);
+		}
+		for (const key of Object.keys(node)) {
+			const value = node[key];
+			if (Array.isArray(value)) {
+				for (const item of value) {
+					if (item && typeof item.type === "string") stack.push(item);
+				}
+			} else if (value && typeof value.type === "string") {
+				stack.push(value);
+			}
+		}
+	}
+	return requires;
+};
+
 /** @typedef {Set<string>} LoggedPaths */
 
 /** @typedef {FileSystemInfoEntry | ExistenceOnlyTimeEntry | "ignore" | null} FileTimestamp */
@@ -2213,6 +2281,38 @@ class FileSystemInfo {
 									});
 								}
 							}
+							// On Bun the children array is empty (unpopulated), so recover the
+							// static require() specifiers by parsing the source; Node/Deno don't.
+							/* istanbul ignore next */
+							if (IS_BUN && module.children.length === 0) {
+								this.fs.readFile(path, (err, content) => {
+									if (err) return callback(err);
+									try {
+										const context = dirname(this.fs, path);
+										const source = /** @type {Buffer} */ (content).toString();
+										/** @type {Set<string>} */
+										const added = new Set();
+										for (const dependency of parseCjsRequires(source)) {
+											if (dependency.startsWith("node:")) continue;
+											if (builtinModules.has(dependency)) continue;
+											if (added.has(dependency)) continue;
+											push({
+												type: RBDT_RESOLVE_CJS_FILE,
+												context,
+												path: dependency,
+												// Best effort: tolerate specifiers that don't resolve.
+												expected: false,
+												issuer: job
+											});
+											added.add(dependency);
+										}
+									} catch (_err) {
+										// Source we can't parse as CommonJS — ignore its dependencies.
+									}
+									process.nextTick(callback);
+								});
+								break;
+							}
 						} else if (supportsEsm && /\.m?js$/.test(path)) {
 							if (!this._warnAboutExperimentalEsmTracking) {
 								logger.log(

package/lib/FlagDependencyUsagePlugin.js

@@ -30,6 +30,19 @@ const {
 const PLUGIN_NAME = "FlagDependencyUsagePlugin";
 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
+ * @returns {boolean} whether unused
+ */
+const IS_UNUSED = (used) => used === UsageState.Unused;
+/**
+ * @param {import("./ExportsInfo").UsageStateType} used usage state
+ * @returns {boolean} whether not used
+ */
+const IS_NOT_USED = (used) => used !== UsageState.Used;
+
 class FlagDependencyUsagePlugin {
 	/**
 	 * Creates an instance of FlagDependencyUsagePlugin.
@@ -162,7 +175,7 @@ class FlagDependencyUsagePlugin {
 											if (nestedInfo) {
 												if (
 													exportInfo.setUsedConditionally(
-														(used) => used === UsageState.Unused,
+														IS_UNUSED,
 														UsageState.OnlyPropertiesUsed,
 														runtime
 													)
@@ -181,7 +194,7 @@ class FlagDependencyUsagePlugin {
 										}
 										if (
 											exportInfo.setUsedConditionally(
-												(v) => v !== UsageState.Used,
+												IS_NOT_USED,
 												UsageState.Used,
 												runtime
 											)
@@ -229,8 +242,9 @@ class FlagDependencyUsagePlugin {
 						// 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.
-						/** @type {Set<Module>} */
-						const mangleableEscapeModules = new Set();
+						// Lazily allocated — usually empty.
+						/** @type {Set<Module> | undefined} */
+						let mangleableEscapeModules;
 
 						/** @type {ArrayQueue<DependenciesBlock>} */
 						const queue = new ArrayQueue();
@@ -273,7 +287,9 @@ class FlagDependencyUsagePlugin {
 								// conservative result and always wins.
 								if (referencedExports === EXPORTS_OBJECT_REFERENCED) {
 									map.set(module, EXPORTS_OBJECT_REFERENCED);
-									mangleableEscapeModules.delete(module);
+									if (mangleableEscapeModules) {
+										mangleableEscapeModules.delete(module);
+									}
 									continue;
 								}
 								// A mangleable whole-object escape keeps the module's exports
@@ -284,6 +300,9 @@ class FlagDependencyUsagePlugin {
 								if (
 									referencedExports === EXPORTS_OBJECT_REFERENCED_MANGLEABLE
 								) {
+									if (mangleableEscapeModules === undefined) {
+										mangleableEscapeModules = new Set();
+									}
 									mangleableEscapeModules.add(module);
 									continue;
 								}
@@ -358,13 +377,15 @@ class FlagDependencyUsagePlugin {
 								);
 							}
 						}
-						for (const module of mangleableEscapeModules) {
-							processReferencedModule(
-								module,
-								EXPORTS_OBJECT_REFERENCED_MANGLEABLE,
-								runtime,
-								forceSideEffects
-							);
+						if (mangleableEscapeModules) {
+							for (const module of mangleableEscapeModules) {
+								processReferencedModule(
+									module,
+									EXPORTS_OBJECT_REFERENCED_MANGLEABLE,
+									runtime,
+									forceSideEffects
+								);
+							}
 						}
 					};