@depup/webpack 5.109.0-depup.0 → 5.109.2-depup.0

package/README.md

@@ -13,8 +13,8 @@ npm install @depup/webpack
 
 | Field | Value |
 |-------|-------|
-| Original | [webpack](https://www.npmjs.com/package/webpack) @ 5.109.0 |
-| Processed | 2026-07-26 |
+| Original | [webpack](https://www.npmjs.com/package/webpack) @ 5.109.2 |
+| Processed | 2026-08-02 |
 | Smoke test | passed |
 | Deps updated | 9 |
 
@@ -23,10 +23,10 @@ npm install @depup/webpack
 | Dependency | From | To |
 |------------|------|-----|
 | @types/estree | ^1.0.8 | ^1.0.9 |
-| acorn | ^8.16.0 | ^8.17.0 |
+| acorn | ^8.16.0 | ^8.18.0 |
 | browserslist | ^4.28.1 | ^4.28.7 |
 | chrome-trace-event | ^1.0.2 | ^1.0.4 |
-| enhanced-resolve | ^5.24.2 | ^5.24.3 |
+| enhanced-resolve | ^5.24.4 | ^5.24.5 |
 | es-module-lexer | ^2.1.0 | ^2.3.1 |
 | eslint-scope | 5.1.1 | ^9.1.2 |
 | events | ^3.2.0 | ^3.3.0 |

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/changes.json

@@ -6,7 +6,7 @@
     },
     "acorn": {
       "from": "^8.16.0",
-      "to": "^8.17.0"
+      "to": "^8.18.0"
     },
     "browserslist": {
       "from": "^4.28.1",
@@ -17,8 +17,8 @@
       "to": "^1.0.4"
     },
     "enhanced-resolve": {
-      "from": "^5.24.2",
-      "to": "^5.24.3"
+      "from": "^5.24.4",
+      "to": "^5.24.5"
     },
     "es-module-lexer": {
       "from": "^2.1.0",
@@ -37,6 +37,6 @@
       "to": "^2.3.3"
     }
   },
-  "timestamp": "2026-07-26T01:00:06.150Z",
+  "timestamp": "2026-08-02T00:59:09.770Z",
   "totalUpdated": 9
 }

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/CleanPlugin.js

@@ -22,10 +22,17 @@ const processAsyncTree = require("./util/processAsyncTree");
 
 /** @typedef {Map<string, number>} Assets */
 
+const createCompilationHooks = () => ({
+	/**
+	 * When returning true the file/directory will be kept during cleaning, returning false will clean it and ignore the following plugins and config.
+	 * @type {SyncBailHook<[string], boolean | void>}
+	 * @since 5.20.0
+	 */
+	keep: new SyncBailHook(["ignore"])
+});
+
 /**
- * Defines the clean plugin compilation hooks type used by this module.
- * @typedef {object} CleanPluginCompilationHooks
- * @property {SyncBailHook<[string], boolean | void>} keep when returning true the file/directory will be kept during cleaning, returning false will clean it and ignore the following plugins and config
+ * @typedef {ReturnType<typeof createCompilationHooks>} CleanPluginCompilationHooks
  */
 
 /**
@@ -484,12 +491,7 @@ class CleanPlugin {
 	}
 }
 
-CleanPlugin.getCompilationHooks = createHooksRegistry(
-	() =>
-		/** @type {CleanPluginCompilationHooks} */ ({
-			keep: new SyncBailHook(["ignore"])
-		})
-);
+CleanPlugin.getCompilationHooks = createHooksRegistry(createCompilationHooks);
 
 module.exports = CleanPlugin;
 module.exports._getDirectories = getDirectories;

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

@@ -884,9 +884,15 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				"runtime"
 			]),
 
-			/** @type {SyncHook<[ExecuteModuleArgument, ExecuteModuleContext]>} */
+			/**
+			 * @type {SyncHook<[ExecuteModuleArgument, ExecuteModuleContext]>}
+			 * @since 5.32.0
+			 */
 			executeModule: new SyncHook(["options", "context"]),
-			/** @type {AsyncParallelHook<[ExecuteModuleArgument, ExecuteModuleContext]>} */
+			/**
+			 * @type {AsyncParallelHook<[ExecuteModuleArgument, ExecuteModuleContext]>}
+			 * @since 5.33.0
+			 */
 			prepareModuleExecution: new AsyncParallelHook(["options", "context"]),
 
 			/** @type {AsyncSeriesHook<[Iterable<Module>]>} */
@@ -1090,7 +1096,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 			processAssets: processAssetsHook,
 			afterProcessAssets: afterProcessAssetsHook,
-			/** @type {AsyncSeriesHook<[CompilationAssets]>} */
+			/**
+			 * @type {AsyncSeriesHook<[CompilationAssets]>}
+			 * @since 5.8.0
+			 */
 			processAdditionalAssets: new AsyncSeriesHook(["assets"]),
 
 			/** @type {SyncBailHook<[], boolean | void>} */
@@ -3504,6 +3513,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 +4767,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 +4797,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/Compiler.js

@@ -222,9 +222,15 @@ class Compiler {
 			/** @type {AsyncSeriesHook<[Compilation]>} */
 			afterCompile: new AsyncSeriesHook(["compilation"]),
 
-			/** @type {AsyncSeriesHook<[]>} */
+			/**
+			 * @type {AsyncSeriesHook<[]>}
+			 * @since 5.67.0
+			 */
 			readRecords: new AsyncSeriesHook([]),
-			/** @type {AsyncSeriesHook<[]>} */
+			/**
+			 * @type {AsyncSeriesHook<[]>}
+			 * @since 5.67.0
+			 */
 			emitRecords: new AsyncSeriesHook([]),
 
 			/** @type {AsyncSeriesHook<[Compiler]>} */
@@ -235,7 +241,10 @@ class Compiler {
 			invalid: new SyncHook(["filename", "changeTime"]),
 			/** @type {SyncHook<[]>} */
 			watchClose: new SyncHook([]),
-			/** @type {AsyncSeriesHook<[]>} */
+			/**
+			 * @type {AsyncSeriesHook<[]>}
+			 * @since 5.17.0
+			 */
 			shutdown: new AsyncSeriesHook([]),
 
 			/** @type {SyncBailHook<[string, string, EXPECTED_ANY[] | undefined], true | void>} */
@@ -243,7 +252,10 @@ class Compiler {
 
 			// TODO the following hooks are weirdly located here
 			// TODO move them for webpack 5
-			/** @type {SyncHook<[]>} */
+			/**
+			 * @type {SyncHook<[]>}
+			 * @since 5.106.0
+			 */
 			validate: new SyncHook([]),
 			/** @type {SyncHook<[]>} */
 			environment: new SyncHook([]),

package/lib/DefinePlugin.js

@@ -628,10 +628,36 @@ const getRuntimeRequirements = (code) => {
 		: [RuntimeGlobals.requireScope];
 };
 
+const createCompilationHooks = () => ({
+	/**
+	 * @type {SyncWaterfallHook<[Record<string, CodeValue>]>}
+	 * @since 5.104.0
+	 */
+	definitions: new SyncWaterfallHook(["definitions"])
+});
+
+/**
+ * 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
- * @property {SyncWaterfallHook<[Record<string, CodeValue>]>} definitions
+ * @typedef {ReturnType<typeof createCompilationHooks>} DefinePluginHooks
  */
 
 /** @typedef {Record<string, CodeValue>} Definitions */
@@ -954,17 +980,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,
@@ -1233,12 +1265,7 @@ class DefinePlugin {
 	}
 }
 
-DefinePlugin.getCompilationHooks = createHooksRegistry(
-	() =>
-		/** @type {DefinePluginHooks} */ ({
-			definitions: new SyncWaterfallHook(["definitions"])
-		})
-);
+DefinePlugin.getCompilationHooks = createHooksRegistry(createCompilationHooks);
 
 module.exports = DefinePlugin;
 module.exports.VALUE_DEP_MAIN = VALUE_DEP_MAIN;

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/ExternalModule.js

@@ -810,10 +810,16 @@ const getSourceForDefaultCase = (optional, request, runtimeTemplate) => {
 /** @typedef {Record<string, string | string[]>} RequestRecord */
 /** @typedef {string | string[] | RequestRecord} ExternalModuleRequest */
 
+const createCompilationHooks = () => ({
+	/**
+	 * @type {SyncBailHook<[Chunk, Compilation], boolean>}
+	 * @since 5.106.0
+	 */
+	chunkCondition: new SyncBailHook(["chunk", "compilation"])
+});
+
 /**
- * Defines the external module hooks type used by this module.
- * @typedef {object} ExternalModuleHooks
- * @property {SyncBailHook<[Chunk, Compilation], boolean>} chunkCondition
+ * @typedef {ReturnType<typeof createCompilationHooks>} ExternalModuleHooks
  */
 
 /**
@@ -1486,10 +1492,7 @@ class ExternalModule extends Module {
 }
 
 ExternalModule.getCompilationHooks = createHooksRegistry(
-	() =>
-		/** @type {ExternalModuleHooks} */ ({
-			chunkCondition: new SyncBailHook(["chunk", "compilation"])
-		})
+	createCompilationHooks
 );
 
 makeSerializable(ExternalModule, "webpack/lib/ExternalModule");