webpack 5.111.1 → 5.112.1

package/lib/{ChunkGraph.js → graph/ChunkGraph.js}

@@ -6,11 +6,9 @@
 "use strict";
 
 const util = require("util");
-const Entrypoint = require("./Entrypoint");
-const ModuleGraphConnection = require("./ModuleGraphConnection");
-const { DEFAULTS } = require("./config/defaults");
-const { first } = require("./util/SetHelpers");
-const SortableSet = require("./util/SortableSet");
+const { DEFAULTS } = require("../config/defaults");
+const { first } = require("../util/SetHelpers");
+const SortableSet = require("../util/SortableSet");
 const {
 	compareIds,
 	compareIterables,
@@ -18,37 +16,39 @@ const {
 	compareModulesByIdentifier,
 	compareSelect,
 	concatComparators
-} = require("./util/comparators");
-const createHash = require("./util/createHash");
-const findGraphRoots = require("./util/findGraphRoots");
+} = require("../util/comparators");
+const createHash = require("../util/createHash");
 const {
 	RuntimeSpecMap,
 	RuntimeSpecSet,
-	forEachRuntime,
 	mergeRuntime,
 	runtimeToString
-} = require("./util/runtime");
+} = require("../util/runtime");
+const ModuleGraphConnection = require("./ModuleGraphConnection");
+const findGraphRoots = require("./findGraphRoots");
 
 /** @import AsyncDependenciesBlock from "./AsyncDependenciesBlock" */
 /** @import Chunk, { Chunks, Entrypoints, ChunkId } from "./Chunk" */
 /** @import ChunkGroup from "./ChunkGroup" */
+/** @import Dependency from "./Dependency" */
+/** @import Entrypoint from "./Entrypoint" */
 /**
  * @import Module, {
  * 	SourceType,
  * 	SourceTypes,
  * 	ReadOnlyRuntimeRequirements,
  * 	RuntimeRequirements
- * } from "./Module"
+ * } from "../module/Module"
  */
 /** @import ModuleGraph from "./ModuleGraph" */
 /** @import { ConnectionState } from "./ModuleGraphConnection" */
-/** @import RuntimeModule from "./RuntimeModule" */
-/** @import { HashFunction } from "./util/Hash" */
-/** @import { RuntimeSpec } from "./util/runtime" */
+/** @import RuntimeModule from "../runtime/RuntimeModule" */
+/** @import { HashFunction } from "../util/Hash" */
+/** @import { RuntimeSpec } from "../util/runtime" */
 /**
  * @import {
  * 	JavascriptModuleBuildMeta
- * } from "./javascript/JavascriptModule"
+ * } from "../javascript/JavascriptModule"
  */
 
 /** @type {ReadonlySet<string>} */
@@ -71,6 +71,15 @@ const activeStateToString = (state) => {
 
 const compareModuleIterables = compareIterables(compareModulesByIdentifier);
 
+/** @type {(a: RuntimeModule, b: RuntimeModule) => -1 | 0 | 1} */
+const compareRuntimeModulesByStage = concatComparators(
+	compareSelect(
+		(module) => /** @type {RuntimeModule} */ (module).stage,
+		compareIds
+	),
+	compareModulesByIdentifier
+);
+
 /** @typedef {(c: Chunk, chunkGraph: ChunkGraph) => boolean} ChunkFilterPredicate */
 /** @typedef {(m: Module) => boolean} ModuleFilterPredicate */
 /** @typedef {[Module, Entrypoint | undefined]} EntryModuleWithChunkGroup */
@@ -106,7 +115,7 @@ const getArray = (set) => [...set];
 
 /**
  * Gets module runtimes.
- * @param {SortableChunks} chunks the chunks
+ * @param {SortableChunks | readonly Chunk[]} chunks the chunks
  * @returns {RuntimeSpecSet} runtimes
  */
 const getModuleRuntimes = (chunks) => {
@@ -155,6 +164,12 @@ const modulesBySourceType = (sourceTypesByModule) => (set) => {
 /** @type {ModulesBySourceType} */
 const defaultModulesBySourceType = modulesBySourceType(undefined);
 
+// What `getModuleChunksIterable` answers for a module in no chunk. Frozen, so a
+// caller ignoring "do not modify" throws here rather than corrupting the answer
+// every such module shares.
+/** @type {readonly Chunk[]} */
+const EMPTY_CHUNKS = Object.freeze([]);
+
 /**
  * Defines the module set to array function type used by this module.
  * @typedef {(set: SortableSet<Module>) => Module[]} ModuleSetToArrayFunction
@@ -242,8 +257,15 @@ const isAvailableChunk = (a, b) => {
 
 class ChunkGraphModule {
 	constructor() {
-		/** @type {SortableChunks} */
-		this.chunks = new SortableSet();
+		// Most modules are in no chunk or one, so: nothing, an array holding that one
+		// chunk, a SortableSet once a second arrives. A set costs 200 bytes against
+		// an array's 56, and of 950 modules 948 hold none, 934 one in development.
+		/** @type {SortableChunks | readonly Chunk[] | undefined} */
+		this.chunks = undefined;
+		// What `getModuleRuntimes` answered, for the states holding no set to cache
+		// in. Dropped wherever `chunks` changes, as the set's own cache is.
+		/** @type {RuntimeSpecSet | undefined} */
+		this.runtimes = undefined;
 		/** @type {EntryInChunks | undefined} */
 		this.entryInChunks = undefined;
 		/** @type {RuntimeInChunks | undefined} */
@@ -339,6 +361,9 @@ class ChunkGraph {
 
 		/** @type {HashFunction} */
 		this._hashFunction = hashFunction;
+		// lets the per-module override lookup bail out until something sets one
+		/** @type {boolean} */
+		this._hasOverwrittenSourceTypes = false;
 
 		this._getGraphRoots = this._getGraphRoots.bind(this);
 	}
@@ -406,6 +431,45 @@ class ChunkGraph {
 		].sort(compareModulesByIdentifier);
 	}
 
+	/**
+	 * Records that a chunk contains a module, growing what the record holds from
+	 * nothing to the one chunk to a set.
+	 * @param {ChunkGraphModule} cgm the module's chunk graph record
+	 * @param {Chunk} chunk the chunk containing it
+	 * @returns {void}
+	 */
+	static _addModuleChunk(cgm, chunk) {
+		const { chunks } = cgm;
+		cgm.runtimes = undefined;
+		if (chunks === undefined) {
+			// Frozen because `getModuleChunks` hands this very array out: nothing here
+			// writes to it after this, and a caller ignoring "do not modify" would
+			// otherwise change membership without the chunk side hearing of it.
+			cgm.chunks = Object.freeze([chunk]);
+		} else if (chunks instanceof Set) {
+			chunks.add(chunk);
+		} else if (chunks[0] !== chunk) {
+			const set = new SortableSet(chunks);
+			set.add(chunk);
+			cgm.chunks = set;
+		}
+	}
+
+	/**
+	 * Records that a chunk no longer contains a module. A set is not shrunk back
+	 * to an array, so a module that was in two chunks keeps the set.
+	 * @param {ChunkGraphModule} cgm the module's chunk graph record
+	 * @param {Chunk} chunk the chunk that no longer contains it
+	 * @returns {void}
+	 */
+	static _removeModuleChunk(cgm, chunk) {
+		const { chunks } = cgm;
+		if (chunks === undefined) return;
+		cgm.runtimes = undefined;
+		if (chunks instanceof Set) chunks.delete(chunk);
+		else if (chunks[0] === chunk) cgm.chunks = undefined;
+	}
+
 	/**
 	 * Connects chunk and module.
 	 * @param {Chunk} chunk the new chunk
@@ -415,7 +479,7 @@ class ChunkGraph {
 	connectChunkAndModule(chunk, module) {
 		const cgm = this._getChunkGraphModule(module);
 		const cgc = this._getChunkGraphChunk(chunk);
-		cgm.chunks.add(chunk);
+		ChunkGraph._addModuleChunk(cgm, chunk);
 		cgc.modules.add(module);
 	}
 
@@ -431,7 +495,7 @@ class ChunkGraph {
 		cgc.modules.delete(module);
 		// No need to invalidate cgc._modulesBySourceType because we modified cgc.modules anyway
 		if (cgc.sourceTypesByModule) cgc.sourceTypesByModule.delete(module);
-		cgm.chunks.delete(chunk);
+		ChunkGraph._removeModuleChunk(cgm, chunk);
 	}
 
 	/**
@@ -443,7 +507,7 @@ class ChunkGraph {
 		const cgc = this._getChunkGraphChunk(chunk);
 		for (const module of cgc.modules) {
 			const cgm = this._getChunkGraphModule(module);
-			cgm.chunks.delete(chunk);
+			ChunkGraph._removeModuleChunk(cgm, chunk);
 		}
 		cgc.modules.clear();
 		chunk.disconnectFromGroups();
@@ -516,13 +580,16 @@ class ChunkGraph {
 		const oldCgm = this._getChunkGraphModule(oldModule);
 		const newCgm = this._getChunkGraphModule(newModule);
 
-		for (const chunk of oldCgm.chunks) {
-			const cgc = this._getChunkGraphChunk(chunk);
-			cgc.modules.delete(oldModule);
-			cgc.modules.add(newModule);
-			newCgm.chunks.add(chunk);
+		if (oldCgm.chunks !== undefined) {
+			for (const chunk of oldCgm.chunks) {
+				const cgc = this._getChunkGraphChunk(chunk);
+				cgc.modules.delete(oldModule);
+				cgc.modules.add(newModule);
+				ChunkGraph._addModuleChunk(newCgm, chunk);
+			}
+			oldCgm.chunks = undefined;
+			oldCgm.runtimes = undefined;
 		}
-		oldCgm.chunks.clear();
 
 		if (oldCgm.entryInChunks !== undefined) {
 			if (newCgm.entryInChunks === undefined) {
@@ -618,8 +685,8 @@ class ChunkGraph {
 	 * @returns {Iterable<Chunk>} iterable of chunks (do not modify)
 	 */
 	getModuleChunksIterable(module) {
-		const cgm = this._getChunkGraphModule(module);
-		return cgm.chunks;
+		const { chunks } = this._getChunkGraphModule(module);
+		return chunks === undefined ? EMPTY_CHUNKS : chunks;
 	}
 
 	/**
@@ -629,9 +696,12 @@ class ChunkGraph {
 	 * @returns {Iterable<Chunk>} iterable of chunks (do not modify)
 	 */
 	getOrderedModuleChunksIterable(module, sortFn) {
-		const cgm = this._getChunkGraphModule(module);
-		cgm.chunks.sortWith(sortFn);
-		return cgm.chunks;
+		const { chunks } = this._getChunkGraphModule(module);
+		if (chunks === undefined) return EMPTY_CHUNKS;
+		// One chunk is in order whatever the comparer says.
+		if (!(chunks instanceof Set)) return chunks;
+		chunks.sortWith(sortFn);
+		return chunks;
 	}
 
 	/**
@@ -640,8 +710,13 @@ class ChunkGraph {
 	 * @returns {Chunk[]} array of chunks (cached, do not modify)
 	 */
 	getModuleChunks(module) {
-		const cgm = this._getChunkGraphModule(module);
-		return cgm.chunks.getFromCache(getArray);
+		const { chunks } = this._getChunkGraphModule(module);
+		if (chunks === undefined) return /** @type {Chunk[]} */ (EMPTY_CHUNKS);
+		// The array a module in one chunk holds is already the answer, and frozen,
+		// as the type this returns cannot say.
+		return chunks instanceof Set
+			? chunks.getFromCache(getArray)
+			: /** @type {Chunk[]} */ (chunks);
 	}
 
 	/**
@@ -650,8 +725,9 @@ class ChunkGraph {
 	 * @returns {number} the number of chunk which contain the module
 	 */
 	getNumberOfModuleChunks(module) {
-		const cgm = this._getChunkGraphModule(module);
-		return cgm.chunks.size;
+		const { chunks } = this._getChunkGraphModule(module);
+		if (chunks === undefined) return 0;
+		return chunks instanceof Set ? chunks.size : chunks.length;
 	}
 
 	/**
@@ -661,7 +737,18 @@ class ChunkGraph {
 	 */
 	getModuleRuntimes(module) {
 		const cgm = this._getChunkGraphModule(module);
-		return cgm.chunks.getFromUnorderedCache(getModuleRuntimes);
+		const { chunks } = cgm;
+		if (chunks instanceof Set) {
+			return chunks.getFromUnorderedCache(getModuleRuntimes);
+		}
+		// Kept on the record, which neither an array nor nothing can do: a build asks
+		// this of every module several times, and scope hoisting leaves most of them
+		// in no chunk at all.
+		if (cgm.runtimes === undefined) {
+			cgm.runtimes =
+				chunks === undefined ? new RuntimeSpecSet() : getModuleRuntimes(chunks);
+		}
+		return cgm.runtimes;
 	}
 
 	/**
@@ -720,6 +807,7 @@ class ChunkGraph {
 			cgc.sourceTypesByModule = new WeakMap();
 		}
 		cgc.sourceTypesByModule.set(module, sourceTypes);
+		this._hasOverwrittenSourceTypes = true;
 		// Update cgc._modulesBySourceType to invalidate the cache
 		cgc._modulesBySourceType = modulesBySourceType(cgc.sourceTypesByModule);
 	}
@@ -755,6 +843,7 @@ class ChunkGraph {
 	 * @returns {SourceTypes | undefined} source types
 	 */
 	_getOverwrittenModuleSourceTypes(module) {
+		if (!this._hasOverwrittenSourceTypes) return;
 		let newSet = false;
 		/** @type {Set<SourceType> | undefined} */
 		let sourceTypes;
@@ -846,6 +935,7 @@ class ChunkGraph {
 	getChunkModuleIdMap(chunk, filterFn, includeAllChunks = false) {
 		/** @type {ChunkModuleIdMap} */
 		const chunkModuleIdMap = Object.create(null);
+		const comparator = compareModulesById(this);
 
 		for (const asyncChunk of includeAllChunks
 			? chunk.getAllReferencedChunks()
@@ -854,7 +944,7 @@ class ChunkGraph {
 			let array;
 			for (const module of this.getOrderedChunkModulesIterable(
 				asyncChunk,
-				compareModulesById(this)
+				comparator
 			)) {
 				if (filterFn(module)) {
 					if (array === undefined) {
@@ -886,6 +976,7 @@ class ChunkGraph {
 	) {
 		/** @type {ChunkModuleHashMap} */
 		const chunkModuleHashMap = Object.create(null);
+		const comparator = compareModulesById(this);
 
 		for (const asyncChunk of includeAllChunks
 			? chunk.getAllReferencedChunks()
@@ -894,7 +985,7 @@ class ChunkGraph {
 			let idToHashMap;
 			for (const module of this.getOrderedChunkModulesIterable(
 				asyncChunk,
-				compareModulesById(this)
+				comparator
 			)) {
 				if (filterFn(module)) {
 					if (idToHashMap === undefined) {
@@ -1350,7 +1441,7 @@ class ChunkGraph {
 		/** @type {Chunks} */
 		const set = new Set();
 		for (const chunkGroup of chunk.groupsIterable) {
-			if (chunkGroup instanceof Entrypoint) {
+			if (chunkGroup.isEntrypoint()) {
 				const entrypointChunk = chunkGroup.getEntrypointChunk();
 				const cgc = this._getChunkGraphChunk(entrypointChunk);
 				for (const chunkGroup of cgc.entryModules.values()) {
@@ -1379,7 +1470,7 @@ class ChunkGraph {
 		const entrypoints = new Set();
 
 		for (const chunkGroup of chunk.groupsIterable) {
-			if (chunkGroup instanceof Entrypoint) {
+			if (chunkGroup.isEntrypoint()) {
 				if (entrypoints.has(chunkGroup)) continue;
 				entrypoints.add(chunkGroup);
 				// `entrypoints` doubles as the visited set: a diamond of `dependOn`
@@ -1389,7 +1480,7 @@ class ChunkGraph {
 					const current = queue[i];
 					let hasChildrenEntrypoint = false;
 					for (const child of current.childrenIterable) {
-						if (child instanceof Entrypoint && child.dependOn(current)) {
+						if (child.isEntrypoint() && child.dependOn(current)) {
 							hasChildrenEntrypoint = true;
 							if (!entrypoints.has(child)) {
 								entrypoints.add(child);
@@ -1458,15 +1549,7 @@ class ChunkGraph {
 	getChunkRuntimeModulesInOrder(chunk) {
 		const cgc = this._getChunkGraphChunk(chunk);
 		const array = [...cgc.runtimeModules];
-		array.sort(
-			concatComparators(
-				compareSelect(
-					(r) => /** @type {RuntimeModule} */ (r).stage,
-					compareIds
-				),
-				compareModulesByIdentifier
-			)
-		);
+		array.sort(compareRuntimeModulesByStage);
 		return array;
 	}
 
@@ -1860,6 +1943,22 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 			const activeNamespaceModules = new Set();
 			/** @type {Map<string, Module | Set<Module>>} */
 			const connectedModules = new Map();
+			// a dependency whose target is missing has no connection, so without
+			// these it hashes like one whose target is inactive, while templates
+			// print a missing-module throw only for the first
+			/** @type {string[] | undefined} */
+			let inactiveRequests;
+			/**
+			 * Records an inactive connection by its request, as templates print nothing of its target.
+			 * @param {ModuleGraphConnection} connection inactive connection
+			 */
+			const addInactive = (connection) => {
+				// only connections without an origin module lack a dependency
+				const dependency = /** @type {Dependency} */ (connection.dependency);
+				(inactiveRequests || (inactiveRequests = [])).push(
+					`${dependency.getResourceIdentifier()}`
+				);
+			};
 			/**
 			 * Process connection.
 			 * @param {ModuleGraphConnection} connection connection
@@ -1885,37 +1984,49 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 			if (runtime === undefined || typeof runtime === "string") {
 				for (const connection of connections) {
 					const state = connection.getActiveState(runtime);
-					if (state === false) continue;
+					if (state === false) {
+						addInactive(connection);
+						continue;
+					}
 					processConnection(connection, state === true ? "T" : "O");
 				}
 			} else {
 				// cspell:word Tnamespace
+				// the runtime is sorted once, so every connection reads it in the same order
+				runtime.sort();
 				for (const connection of connections) {
-					/** @type {Set<ConnectionState>} */
-					const states = new Set();
+					/** @type {ConnectionState | undefined} */
+					let firstState;
+					let sameState = true;
 					let stateInfo = "";
-					forEachRuntime(
-						runtime,
-						(runtime) => {
-							const state = connection.getActiveState(runtime);
-							states.add(state);
-							stateInfo += activeStateToString(state) + runtime;
-						},
-						true
-					);
-					if (states.size === 1) {
-						const state = first(states);
-						if (state === false) continue;
+					for (const runtimeName of runtime) {
+						const state = connection.getActiveState(runtimeName);
+						if (firstState === undefined) {
+							firstState = state;
+						} else if (state !== firstState) {
+							sameState = false;
+						}
+						stateInfo += activeStateToString(state) + runtimeName;
+					}
+					if (sameState) {
+						if (firstState === false) {
+							addInactive(connection);
+							continue;
+						}
 						stateInfo = activeStateToString(
 							/** @type {ConnectionState} */
-							(state)
+							(firstState)
 						);
 					}
 					processConnection(connection, stateInfo);
 				}
 			}
 			// cspell:word Tnamespace
-			if (activeNamespaceModules.size === 0 && connectedModules.size === 0) {
+			if (
+				activeNamespaceModules.size === 0 &&
+				connectedModules.size === 0 &&
+				inactiveRequests === undefined
+			) {
 				return graphHash;
 			}
 			const connectedModulesInOrder =
@@ -1966,6 +2077,11 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 					addModuleToHash(modules);
 				}
 			}
+			if (inactiveRequests !== undefined) {
+				// connections arrive as resolutions finish, so sort like connectedModules
+				if (inactiveRequests.length > 1) inactiveRequests.sort();
+				hash.update(JSON.stringify(inactiveRequests));
+			}
 			hash.update(graphHash);
 			return hash.digest("hex");
 		});
@@ -1981,7 +2097,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 		return cgc.runtimeRequirementsInTree;
 	}
 
-	// TODO remove in webpack 6
+	// TODO in the next major release: remove
 	/**
 	 * Gets chunk graph for module.
 	 * @deprecated
@@ -2003,9 +2119,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 				const chunkGraph = chunkGraphForModuleMap.get(module);
 				if (!chunkGraph) {
 					throw new Error(
-						`${
-							deprecateMessage
-						}: There was no ChunkGraph assigned to the Module for backward-compat (Use the new API)`
+						`${deprecateMessage}: There was no ChunkGraph assigned to the Module for backward-compat (Use the new API)`
 					);
 				}
 				return chunkGraph;
@@ -2017,7 +2131,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 		return newFn(module);
 	}
 
-	// TODO remove in webpack 6
+	// TODO in the next major release: remove
 	// BACKWARD-COMPAT START
 	/**
 	 * Sets chunk graph for module.
@@ -2061,9 +2175,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 				const chunkGraph = chunkGraphForChunkMap.get(chunk);
 				if (!chunkGraph) {
 					throw new Error(
-						`${
-							deprecateMessage
-						}There was no ChunkGraph assigned to the Chunk for backward-compat (Use the new API)`
+						`${deprecateMessage}There was no ChunkGraph assigned to the Chunk for backward-compat (Use the new API)`
 					);
 				}
 				return chunkGraph;
@@ -2098,19 +2210,19 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 	// BACKWARD-COMPAT END
 }
 
-// TODO remove in webpack 6
+// TODO in the next major release: remove
 /** @type {WeakMap<Module, ChunkGraph>} */
 const chunkGraphForModuleMap = new WeakMap();
 
-// TODO remove in webpack 6
+// TODO in the next major release: remove
 /** @type {WeakMap<Chunk, ChunkGraph>} */
 const chunkGraphForChunkMap = new WeakMap();
 
-// TODO remove in webpack 6
+// TODO in the next major release: remove
 /** @type {Map<string, (module: Module) => ChunkGraph>} */
 const deprecateGetChunkGraphForModuleMap = new Map();
 
-// TODO remove in webpack 6
+// TODO in the next major release: remove
 /** @type {Map<string, (chunk: Chunk) => ChunkGraph>} */
 const deprecateGetChunkGraphForChunkMap = new Map();
 

package/lib/{ChunkGroup.js → graph/ChunkGroup.js}

@@ -6,19 +6,19 @@
 "use strict";
 
 const util = require("util");
-const SortableSet = require("./util/SortableSet");
+const SortableSet = require("../util/SortableSet");
 const {
 	compareChunks,
 	compareIterables,
 	compareLocations
-} = require("./util/comparators");
+} = require("../util/comparators");
 
 /** @import AsyncDependenciesBlock from "./AsyncDependenciesBlock" */
 /** @import Chunk from "./Chunk" */
 /** @import ChunkGraph from "./ChunkGraph" */
 /** @import { DependencyLocation } from "./Dependency" */
 /** @import Entrypoint from "./Entrypoint" */
-/** @import Module from "./Module" */
+/** @import Module from "../module/Module" */
 /** @import ModuleGraph from "./ModuleGraph" */
 
 /** @typedef {{ module: Module | null, loc: DependencyLocation, request: string }} OriginRecord */
@@ -299,6 +299,14 @@ class ChunkGroup {
 		return false;
 	}
 
+	/**
+	 * Returns whether this chunk group is an entrypoint, an async one (e.g. a worker) included.
+	 * @returns {this is Entrypoint} true for an entrypoint
+	 */
+	isEntrypoint() {
+		return false;
+	}
+
 	/**
 	 * Adds a child chunk group to the current group.
 	 * @param {ChunkGroup} group chunk group to add

package/lib/{DependenciesBlock.js → graph/DependenciesBlock.js}

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const makeSerializable = require("./util/makeSerializable");
+const makeSerializable = require("../util/makeSerializable");
 
 /** @import AsyncDependenciesBlock from "./AsyncDependenciesBlock" */
 /** @import Dependency, { UpdateHashContext } from "./Dependency" */
@@ -13,9 +13,9 @@ const makeSerializable = require("./util/makeSerializable");
  * @import {
  * 	ObjectDeserializerContext,
  * 	ObjectSerializerContext
- * } from "./serialization/ObjectMiddleware"
+ * } from "../serialization/ObjectMiddleware"
  */
-/** @import Hash from "./util/Hash" */
+/** @import Hash from "../util/Hash" */
 
 /** @typedef {(d: Dependency) => boolean} DependencyFilterFunction */
 
@@ -37,6 +37,14 @@ class DependenciesBlock {
 		this.parent = undefined;
 	}
 
+	/**
+	 * Returns whether this block is an async block, loaded on demand in its own chunk group.
+	 * @returns {this is AsyncDependenciesBlock} true for an AsyncDependenciesBlock
+	 */
+	isAsyncBlock() {
+		return false;
+	}
+
 	getRootBlock() {
 		/** @type {DependenciesBlock} */
 		let current = this;
@@ -123,6 +131,10 @@ class DependenciesBlock {
 	}
 }
 
-makeSerializable(DependenciesBlock, "webpack/lib/DependenciesBlock");
+makeSerializable(DependenciesBlock, [
+	"webpack/lib/graph/DependenciesBlock",
+	// TODO in the next major release: remove, they restore pre-move cache packs
+	"webpack/lib/DependenciesBlock"
+]);
 
 module.exports = DependenciesBlock;