webpack 5.111.0 → 5.112.0

package/lib/{APIPlugin.js → javascript/APIPlugin.js}

@@ -5,50 +5,49 @@
 
 "use strict";
 
+const ConstDependency = require("../dependencies/core/ConstDependency");
+const ModuleInitFragmentDependency = require("../dependencies/core/ModuleInitFragmentDependency");
+const RuntimeRequirementsDependency = require("../dependencies/core/RuntimeRequirementsDependency");
+const WebpackError = require("../errors/WebpackError");
 const {
 	getExternalModuleNodeCommonjsInitFragment
-} = require("./ExternalModule");
+} = require("../externals/ExternalModule");
+const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
+const JavascriptModulesPlugin = require("../javascript/JavascriptModulesPlugin");
+const {
+	evaluateToString,
+	toConstantDependency
+} = require("../javascript/JavascriptParserHelpers");
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
 	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
 	JAVASCRIPT_MODULE_TYPE_ESM
-} = require("./ModuleTypeConstants");
-const RuntimeGlobals = require("./RuntimeGlobals");
-const ConstDependency = require("./dependencies/ConstDependency");
-const ModuleInitFragmentDependency = require("./dependencies/ModuleInitFragmentDependency");
-const RuntimeRequirementsDependency = require("./dependencies/RuntimeRequirementsDependency");
-const WebpackError = require("./errors/WebpackError");
-const BasicEvaluatedExpression = require("./javascript/BasicEvaluatedExpression");
-const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin");
-const {
-	evaluateToString,
-	toConstantDependency
-} = require("./javascript/JavascriptParserHelpers");
-const ChunkNameRuntimeModule = require("./runtime/ChunkNameRuntimeModule");
-const GetFullHashRuntimeModule = require("./runtime/GetFullHashRuntimeModule");
-const memoize = require("./util/memoize");
-const { forEachRuntime } = require("./util/runtime");
+} = require("../module/ModuleTypeConstants");
+const ChunkNameRuntimeModule = require("../runtime/ChunkNameRuntimeModule");
+const GetFullHashRuntimeModule = require("../runtime/GetFullHashRuntimeModule");
+const RuntimeGlobals = require("../runtime/RuntimeGlobals");
+const memoize = require("../util/memoize");
+const { forEachRuntime } = require("../util/runtime");
 
 const getConcatenatedModule = memoize(() =>
-	require("./optimize/ConcatenatedModule")
+	require("../optimize/ConcatenatedModule")
 );
 
-/** @import Compiler from "./Compiler" */
-/** @import Module, { BuildInfo } from "./Module" */
+/** @import Compiler from "../Compiler" */
+/** @import Module, { BuildInfo } from "../module/Module" */
 /**
  * @import {
  * 	JavascriptModuleBuildInfo
- * } from "./javascript/JavascriptModule"
+ * } from "../javascript/JavascriptModule"
  */
-/** @import Compilation from "./Compilation" */
-/** @import ChunkGraph from "./ChunkGraph" */
-/** @import { RuntimeSpec } from "./util/runtime" */
-/** @import JavascriptParser, { Range } from "./javascript/JavascriptParser" */
-
-// Modules that reassign `__webpack_public_path__` at runtime, by compilation. A baked
-// analyzable specifier can't reflect that, so those forms fall back. Also recorded per
-// module in `buildInfo`, because a module restored from the persistent cache is never
-// re-parsed and would otherwise lose the flag.
+/** @import Compilation from "../Compilation" */
+/** @import ChunkGraph from "../graph/ChunkGraph" */
+/** @import { RuntimeSpec } from "../util/runtime" */
+/** @import JavascriptParser, { Range } from "../javascript/JavascriptParser" */
+
+// Modules reassigning `__webpack_public_path__` at runtime, per compilation, since
+// a baked specifier cannot reflect that. Also kept in `buildInfo`: a module
+// restored from the persistent cache is never re-parsed.
 /** @type {WeakMap<Compilation, Set<Module>>} */
 const runtimePublicPathOverride = new WeakMap();
 

package/lib/javascript/ArrayPushCallbackChunkFormatPlugin.js

@@ -7,8 +7,7 @@
 
 const { ConcatSource, PrefixSource, RawSource } = require("webpack-sources");
 const { RuntimeGlobals } = require("..");
-const HotUpdateChunk = require("../HotUpdateChunk");
-const Template = require("../Template");
+const Template = require("../template/Template");
 const { getCompilationHooks } = require("./JavascriptModulesPlugin");
 const {
 	generateEntryStartup,
@@ -16,8 +15,8 @@ const {
 } = require("./StartupHelpers");
 
 /** @import Compiler from "../Compiler" */
-/** @import { EntryModuleWithChunkGroup } from "../ChunkGraph" */
-/** @import CodeGenerationResults from "../CodeGenerationResults" */
+/** @import { EntryModuleWithChunkGroup } from "../graph/ChunkGraph" */
+/** @import CodeGenerationResults from "../module/CodeGenerationResults" */
 
 const PLUGIN_NAME = "ArrayPushCallbackChunkFormatPlugin";
 
@@ -44,7 +43,7 @@ class ArrayPushCallbackChunkFormatPlugin {
 			const hooks = getCompilationHooks(compilation);
 			hooks.renderChunk.tap(PLUGIN_NAME, (modules, renderContext) => {
 				const { chunk, chunkGraph, runtimeTemplate } = renderContext;
-				const hotUpdateChunk = chunk instanceof HotUpdateChunk ? chunk : null;
+				const hotUpdateChunk = chunk.isHotUpdate() ? chunk : null;
 				const globalObject = runtimeTemplate.globalObject;
 				const source = new ConcatSource();
 				const runtimeModules = chunkGraph.getChunkRuntimeModulesInOrder(chunk);

package/lib/javascript/BasicEvaluatedExpression.js

@@ -290,16 +290,16 @@ class BasicEvaluatedExpression {
 	}
 
 	/**
-	 * @returns {EXPECTED_ANY[] | undefined} const array values
+	 * @returns {string[] | undefined} const array values
 	 */
 	get array() {
 		return this.type === TypeConstArray
-			? /** @type {unknown[]} */ (this._v1)
+			? /** @type {string[]} */ (this._v1)
 			: undefined;
 	}
 
 	/**
-	 * @param {EXPECTED_ANY[] | undefined} value const array values
+	 * @param {string[] | undefined} value const array values
 	 */
 	set array(value) {
 		this._v1 = value;
@@ -487,7 +487,7 @@ class BasicEvaluatedExpression {
 
 	/**
 	 * As compile time value.
-	 * @returns {undefined | null | string | number | boolean | RegExp | EXPECTED_ANY[] | bigint} the javascript value
+	 * @returns {undefined | null | string | number | boolean | RegExp | string[] | bigint} the javascript value
 	 */
 	asCompileTimeValue() {
 		switch (this.type) {

package/lib/javascript/ChunkHelpers.js

@@ -5,9 +5,12 @@
 
 "use strict";
 
-const Entrypoint = require("../Entrypoint");
-
-/** @import Chunk from "../Chunk" */
+/** @import Chunk from "../graph/Chunk" */
+/** @import ChunkGraph from "../graph/ChunkGraph" */
+/** @import Entrypoint from "../graph/Entrypoint" */
+/** @import Module from "../module/Module" */
+/** @import Hash from "../util/Hash" */
+/** @import { ChunkHashContext } from "../Compilation" */
 
 /**
  * Returns chunks.
@@ -26,7 +29,7 @@ const getAllChunks = (entrypoint, excludedChunk1, excludedChunk2) => {
 			groups.add(group);
 		}
 		for (const parent of group.parentsIterable) {
-			if (parent instanceof Entrypoint) queue.add(parent);
+			if (parent.isEntrypoint()) queue.add(parent);
 		}
 	}
 	groups.add(entrypoint);
@@ -43,4 +46,61 @@ const getAllChunks = (entrypoint, excludedChunk1, excludedChunk2) => {
 	return chunks;
 };
 
+/**
+ * Returns } Object containing chunk entries and runtime chunk.
+ * @param {Chunk} chunk The chunk to get information for
+ * @param {ChunkGraph} chunkGraph The chunk graph containing the chunk
+ * @returns {{ entries: [Module, Entrypoint | undefined][], runtimeChunk: Chunk | null }} Object containing chunk entries and runtime chunk
+ */
+function getChunkInfo(chunk, chunkGraph) {
+	const entries = [
+		...chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
+	];
+	const runtimeChunk =
+		entries.length > 0
+			? /** @type {Entrypoint[][]} */
+				(entries)[0][1].getRuntimeChunk()
+			: null;
+
+	return {
+		entries,
+		runtimeChunk
+	};
+}
+
+/**
+ * Creates a chunk hash handler
+ * @param {string} name The name of the chunk
+ * @returns {(chunk: Chunk, hash: Hash, { chunkGraph }: ChunkHashContext) => void} The chunk hash handler
+ */
+function createChunkHashHandler(name) {
+	/**
+	 * Processes the provided chunk.
+	 * @param {Chunk} chunk The chunk to get information for
+	 * @param {Hash} hash The hash to update
+	 * @param {ChunkHashContext} chunkHashContext The chunk hash context
+	 * @returns {void}
+	 */
+	return (chunk, hash, { chunkGraph }) => {
+		if (chunk.hasRuntime()) return;
+		const { entries, runtimeChunk } = getChunkInfo(chunk, chunkGraph);
+		hash.update(name);
+		hash.update("1");
+		if (runtimeChunk && runtimeChunk.hash) {
+			// WHY: any change to the runtime chunk must move this hash, and its
+			// internal implementation is not ours to depend on or inspect — the import
+			// names its hashed filename:
+			// import __webpack_require__ from "./runtime-main.e9400aee33633a3973bd.js";
+			// https://github.com/webpack/webpack/issues/19439
+			hash.update(runtimeChunk.hash);
+		}
+
+		const { updateHashForEntryStartup } = require("./StartupHelpers");
+
+		updateHashForEntryStartup(hash, chunkGraph, entries, chunk);
+	};
+}
+
 module.exports.getAllChunks = getAllChunks;
+module.exports.createChunkHashHandler = createChunkHashHandler;
+module.exports.getChunkInfo = getChunkInfo;

package/lib/javascript/CommonJsChunkFormatPlugin.js

@@ -6,13 +6,10 @@
 "use strict";
 
 const { ConcatSource, RawSource } = require("webpack-sources");
-const RuntimeGlobals = require("../RuntimeGlobals");
-const Template = require("../Template");
+const RuntimeGlobals = require("../runtime/RuntimeGlobals");
+const Template = require("../template/Template");
 const { getUndoPath } = require("../util/identifier");
-const {
-	createChunkHashHandler,
-	getChunkInfo
-} = require("./ChunkFormatHelpers");
+const { createChunkHashHandler, getChunkInfo } = require("./ChunkHelpers");
 const {
 	getChunkFilenameTemplate,
 	getCompilationHooks
@@ -22,7 +19,7 @@ const {
 	generateEntryStartup
 } = require("./StartupHelpers");
 
-/** @import Chunk from "../Chunk" */
+/** @import Chunk from "../graph/Chunk" */
 /** @import Compiler from "../Compiler" */
 
 const PLUGIN_NAME = "CommonJsChunkFormatPlugin";

package/lib/{CompatibilityPlugin.js → javascript/CompatibilityPlugin.js}

@@ -5,19 +5,19 @@
 
 "use strict";
 
+const ConstDependency = require("../dependencies/core/ConstDependency");
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
 	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
 	JAVASCRIPT_MODULE_TYPE_ESM
-} = require("./ModuleTypeConstants");
-const RuntimeGlobals = require("./RuntimeGlobals");
-const ConstDependency = require("./dependencies/ConstDependency");
+} = require("../module/ModuleTypeConstants");
+const RuntimeGlobals = require("../runtime/RuntimeGlobals");
 
 /** @import { CallExpression } from "estree" */
-/** @import Compiler from "./Compiler" */
-/** @import { DependencyLocation } from "./Dependency" */
-/** @import ContextDependency from "./dependencies/ContextDependency" */
-/** @import JavascriptParser, { Range } from "./javascript/JavascriptParser" */
+/** @import Compiler from "../Compiler" */
+/** @import { DependencyLocation } from "../graph/Dependency" */
+/** @import ContextDependency from "../dependencies/context/ContextDependency" */
+/** @import JavascriptParser, { Range } from "../javascript/JavascriptParser" */
 
 /**
  * Captures the source range of a renamed compatibility binding so it can be
@@ -180,10 +180,9 @@ 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.
+					// `const` and `let` are block-pre-walked, by which point the name is no
+					// longer free and `hooks.pattern` never fires, so they are tagged
+					// through the declaration hooks instead.
 					for (const hookMap of [
 						parser.hooks.varDeclarationConst,
 						parser.hooks.varDeclarationLet

package/lib/{ConstPlugin.js → javascript/ConstPlugin.js}

@@ -5,29 +5,30 @@
 
 "use strict";
 
+const CachedConstDependency = require("../dependencies/core/CachedConstDependency");
+const ConstDependency = require("../dependencies/core/ConstDependency");
+const { evaluateToString } = require("../javascript/JavascriptParserHelpers");
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
 	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
 	JAVASCRIPT_MODULE_TYPE_ESM
-} = require("./ModuleTypeConstants");
-const CachedConstDependency = require("./dependencies/CachedConstDependency");
-const ConstDependency = require("./dependencies/ConstDependency");
-const { evaluateToString } = require("./javascript/JavascriptParserHelpers");
-const { parseResource } = require("./util/identifier");
+} = require("../module/ModuleTypeConstants");
+const { parseResource } = require("../util/identifier");
 
 /**
  * @import {
  * 	AssignmentProperty,
  * 	Expression,
  * 	Identifier,
+ * 	LogicalExpression,
  * 	Pattern,
  * 	Statement,
  * 	Super,
  * 	VariableDeclaration
  * } from "estree"
  */
-/** @import Compiler from "./Compiler" */
-/** @import JavascriptParser, { Range } from "./javascript/JavascriptParser" */
+/** @import Compiler from "../Compiler" */
+/** @import JavascriptParser, { Range } from "../javascript/JavascriptParser" */
 
 /** @typedef {Set<string>} Declarations */
 
@@ -140,6 +141,71 @@ const getHoistedDeclarations = (branch, includeFunctionDeclarations) => {
 
 const PLUGIN_NAME = "ConstPlugin";
 
+/**
+ * @param {JavascriptParser} parser the parser
+ * @param {Expression} expression the operand
+ * @returns {boolean} whether the built-in evaluator cannot resolve the operand
+ */
+const isUnknownLocal = (parser, expression) => {
+	const root = parser.getMemberExpressionRoot(expression);
+	return (
+		root.type === "Identifier" &&
+		root.name !== "undefined" &&
+		parser._isDefinedPlainVariable(root.name)
+	);
+};
+
+/**
+ * Walks chains of unknown locals without evaluating every prefix.
+ * @param {JavascriptParser} parser the parser
+ * @param {LogicalExpression} expression the logical chain
+ * @returns {boolean} whether the entire expression was walked
+ */
+const walkUnknownLocalChain = (parser, expression) => {
+	if (expression.left.type !== "LogicalExpression") return false;
+	const logicalHook = parser.hooks.expressionLogicalOperator;
+	if (logicalHook.interceptors.length !== 0 || logicalHook.taps.length !== 1) {
+		return false;
+	}
+	for (const type of ["Identifier", "MemberExpression", "LogicalExpression"]) {
+		const hook = parser.hooks.evaluate.get(type);
+		if (
+			hook &&
+			(hook.interceptors.length !== 0 ||
+				hook.taps.some(
+					(tap) =>
+						tap.name !== "JavascriptParser" &&
+						// ImportMetaPlugin only evaluates members rooted at import.meta.
+						!(type === "MemberExpression" && tap.name === "ImportMetaPlugin")
+				))
+		) {
+			return false;
+		}
+	}
+	/** @type {Expression[]} */
+	const rightOperands = [];
+	/** @type {Expression} */
+	let current = expression;
+	while (current.type === "LogicalExpression") {
+		if (
+			current.operator !== expression.operator ||
+			!isUnknownLocal(parser, current.right)
+		) {
+			return false;
+		}
+		rightOperands.push(current.right);
+		current = current.left;
+	}
+	if (!isUnknownLocal(parser, current)) return false;
+	// All prefix evaluations precede the first operand walk. Keep that order:
+	// walking an operand may change the parser's bindings or plugin state.
+	parser.walkExpression(current);
+	for (let index = rightOperands.length - 1; index >= 0; index--) {
+		parser.walkExpression(rightOperands[index]);
+	}
+	return true;
+};
+
 class ConstPlugin {
 	/**
 	 * Applies the plugin by registering its hooks on the compiler.
@@ -219,17 +285,8 @@ class ConstPlugin {
 								} else {
 									parser.walkExpression(expression.test);
 								}
-								// Expressions do not hoist.
-								// It is safe to remove the dead branch.
-								//
-								// Given the following code:
-								//
-								//   false ? someExpression() : otherExpression();
-								//
-								// the generated code is:
-								//
-								//   false ? 0 : otherExpression();
-								//
+								// Expressions do not hoist, so the dead branch is safe to remove:
+								// `false ? someExpression() : other()` becomes `false ? 0 : other()`.
 								const branchToRemove = bool
 									? expression.alternate
 									: expression.consequent;
@@ -251,52 +308,13 @@ class ConstPlugin {
 								expression.operator === "&&" ||
 								expression.operator === "||"
 							) {
+								if (walkUnknownLocalChain(parser, expression)) return false;
 								const param = parser.evaluateExpression(expression.left);
 								const bool = param.asBool();
 								if (typeof bool === "boolean") {
-									// Expressions do not hoist.
-									// It is safe to remove the dead branch.
-									//
-									// ------------------------------------------
-									//
-									// Given the following code:
-									//
-									//   falsyExpression() && someExpression();
-									//
-									// the generated code is:
-									//
-									//   falsyExpression() && false;
-									//
-									// ------------------------------------------
-									//
-									// Given the following code:
-									//
-									//   truthyExpression() && someExpression();
-									//
-									// the generated code is:
-									//
-									//   true && someExpression();
-									//
-									// ------------------------------------------
-									//
-									// Given the following code:
-									//
-									//   truthyExpression() || someExpression();
-									//
-									// the generated code is:
-									//
-									//   truthyExpression() || false;
-									//
-									// ------------------------------------------
-									//
-									// Given the following code:
-									//
-									//   falsyExpression() || someExpression();
-									//
-									// the generated code is:
-									//
-									//   false && someExpression();
-									//
+									// Expressions do not hoist, so the dead branch is safe to remove.
+									// Whichever side cannot decide the result is replaced, leaving the
+									// deciding side and its side effects in place.
 									const keepRight =
 										(expression.operator === "&&" && bool) ||
 										(expression.operator === "||" && !bool);
@@ -305,14 +323,8 @@ class ConstPlugin {
 										!param.couldHaveSideEffects() &&
 										(param.isBoolean() || keepRight)
 									) {
-										// for case like
-										//
-										//   return'development'===process.env.NODE_ENV&&'foo'
-										//
-										// we need a space before the bool to prevent result like
-										//
-										//   returnfalse&&'foo'
-										//
+										// The bool needs a leading space: `return'a'===b&&'foo'` would
+										// otherwise become `returnfalse&&'foo'`.
 										const dep = new ConstDependency(
 											` ${bool}`,
 											/** @type {Range} */ (param.range)
@@ -336,36 +348,12 @@ class ConstPlugin {
 								const param = parser.evaluateExpression(expression.left);
 								const keepRight = param.asNullish();
 								if (typeof keepRight === "boolean") {
-									// ------------------------------------------
-									//
-									// Given the following code:
-									//
-									//   nonNullish ?? someExpression();
-									//
-									// the generated code is:
-									//
-									//   nonNullish ?? 0;
-									//
-									// ------------------------------------------
-									//
-									// Given the following code:
-									//
-									//   nullish ?? someExpression();
-									//
-									// the generated code is:
-									//
-									//   null ?? someExpression();
-									//
+									// `nonNullish ?? x` becomes `nonNullish ?? 0`, and `nullish ?? x`
+									// becomes `null ?? x`: the unreachable side is replaced.
 									if (!param.couldHaveSideEffects() && keepRight) {
 										// cspell:word returnnull
-										// for case like
-										//
-										//   return('development'===process.env.NODE_ENV&&null)??'foo'
-										//
-										// we need a space before the bool to prevent result like
-										//
-										//   returnnull??'foo'
-										//
+										// As above, the value needs a leading space, or `return(…&&null)`
+										// would become `returnnull??'foo'`.
 										const dep = new ConstDependency(
 											" null",
 											/** @type {Range} */ (param.range)
@@ -423,18 +411,8 @@ class ConstPlugin {
 							);
 
 							if (evaluated.asNullish()) {
-								// ------------------------------------------
-								//
-								// Given the following code:
-								//
-								//   nullishMemberChain?.a.b();
-								//
-								// the generated code is:
-								//
-								//   undefined;
-								//
-								// ------------------------------------------
-								//
+								// A nullish chain short-circuits whole, so `nullish?.a.b()`
+								// becomes `undefined`.
 								const dep = new ConstDependency(
 									" undefined",
 									/** @type {Range} */ (expr.range)
@@ -519,36 +497,9 @@ class ConstPlugin {
 	 * @returns {void}
 	 */
 	eliminateUnusedStatement(parser, statement, alwaysInBlock) {
-		// Before removing the unused branch, the hoisted declarations
-		// must be collected.
-		//
-		// Given the following code:
-		//
-		//     if (true) f() else g()
-		//     if (false) {
-		//       function f() {}
-		//       const g = function g() {}
-		//       if (someTest) {
-		//         let a = 1
-		//         var x, {y, z} = obj
-		//       }
-		//     } else {
-		//       …
-		//     }
-		//
-		// the generated code is:
-		//
-		//     if (true) f() else {}
-		//     if (false) {
-		//       var f, x, y, z;   (in loose mode)
-		//       var x, y, z;      (in strict mode)
-		//     } else {
-		//       …
-		//     }
-		//
-		// NOTE: When code runs in strict mode, `var` declarations
-		// are hoisted but `function` declarations don't.
-		//
+		// The hoisted declarations must be collected before the unused branch goes,
+		// since the removed code still contributes them. In strict mode `var` is
+		// hoisted but `function` is not, so the two modes collect different sets.
 		const declarations = parser.scope.isStrict
 			? getHoistedDeclarations(statement, false)
 			: getHoistedDeclarations(statement, true);

package/lib/{ExportsInfoApiPlugin.js → javascript/ExportsInfoApiPlugin.js}

@@ -5,16 +5,16 @@
 
 "use strict";
 
+const ConstDependency = require("../dependencies/core/ConstDependency");
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
 	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
 	JAVASCRIPT_MODULE_TYPE_ESM
-} = require("./ModuleTypeConstants");
-const ConstDependency = require("./dependencies/ConstDependency");
-const ExportsInfoDependency = require("./dependencies/ExportsInfoDependency");
+} = require("../module/ModuleTypeConstants");
+const ExportsInfoDependency = require("./ExportsInfoDependency");
 
-/** @import Compiler from "./Compiler" */
-/** @import JavascriptParser, { Range } from "./javascript/JavascriptParser" */
+/** @import Compiler from "../Compiler" */
+/** @import JavascriptParser, { Range } from "../javascript/JavascriptParser" */
 
 const PLUGIN_NAME = "ExportsInfoApiPlugin";
 

package/lib/{dependencies → javascript}/ExportsInfoDependency.js

@@ -5,15 +5,15 @@
 
 "use strict";
 
-const { UsageState } = require("../ExportsInfo");
+const NullDependency = require("../dependencies/core/NullDependency");
+const { UsageState } = require("../graph/ExportsInfo");
 const makeSerializable = require("../util/makeSerializable");
-const NullDependency = require("./NullDependency");
 
 /** @import { ReplaceSource } from "webpack-sources" */
-/** @import Dependency, { ExportInfoName } from "../Dependency" */
-/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
-/** @import Module from "../Module" */
-/** @import ModuleGraph from "../ModuleGraph" */
+/** @import Dependency, { ExportInfoName } from "../graph/Dependency" */
+/** @import { DependencyTemplateContext } from "../template/DependencyTemplate" */
+/** @import Module from "../module/Module" */
+/** @import ModuleGraph from "../graph/ModuleGraph" */
 /** @import { Range } from "../javascript/JavascriptParser" */
 /** @import { RuntimeSpec } from "../util/runtime" */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Range, ExportInfoName[] | null, string | null]>} ObjectDeserializerContext */
@@ -130,10 +130,11 @@ class ExportsInfoDependency extends NullDependency {
 	}
 }
 
-makeSerializable(
-	ExportsInfoDependency,
+makeSerializable(ExportsInfoDependency, [
+	"webpack/lib/javascript/ExportsInfoDependency",
+	// TODO in the next major release: remove, they restore pre-move cache packs
 	"webpack/lib/dependencies/ExportsInfoDependency"
-);
+]);
 
 ExportsInfoDependency.Template = class ExportsInfoDependencyTemplate extends (
 	NullDependency.Template