webpack 5.97.1 → 5.104.1

package/lib/ChunkGraph.js

@@ -8,33 +8,38 @@
 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 {
-	compareModulesById,
+	compareIds,
 	compareIterables,
+	compareModulesById,
 	compareModulesByIdentifier,
-	concatComparators,
 	compareSelect,
-	compareIds
+	concatComparators
 } = require("./util/comparators");
 const createHash = require("./util/createHash");
 const findGraphRoots = require("./util/findGraphRoots");
 const {
 	RuntimeSpecMap,
 	RuntimeSpecSet,
-	runtimeToString,
+	forEachRuntime,
 	mergeRuntime,
-	forEachRuntime
+	runtimeToString
 } = require("./util/runtime");
 
 /** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
 /** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./Chunk").Chunks} Chunks */
+/** @typedef {import("./Chunk").Entrypoints} Entrypoints */
 /** @typedef {import("./Chunk").ChunkId} ChunkId */
 /** @typedef {import("./ChunkGroup")} ChunkGroup */
-/** @typedef {import("./Generator").SourceTypes} SourceTypes */
 /** @typedef {import("./Module")} Module */
+/** @typedef {import("./Module").SourceType} SourceType */
+/** @typedef {import("./Module").SourceTypes} SourceTypes */
 /** @typedef {import("./Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
+/** @typedef {import("./Module").RuntimeRequirements} RuntimeRequirements */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @typedef {import("./RuntimeModule")} RuntimeModule */
@@ -61,7 +66,7 @@ const compareModuleIterables = compareIterables(compareModulesByIdentifier);
 class ModuleHashInfo {
 	/**
 	 * @param {string} hash hash
-	 * @param {string} renderedHash  rendered hash
+	 * @param {string} renderedHash rendered hash
 	 */
 	constructor(hash, renderedHash) {
 		this.hash = hash;
@@ -69,20 +74,18 @@ class ModuleHashInfo {
 	}
 }
 
-/** @template T @typedef {(set: SortableSet<T>) => T[]} SetToArrayFunction<T> */
-
 /**
  * @template T
  * @param {SortableSet<T>} set the set
  * @returns {T[]} set as array
  */
-const getArray = set => Array.from(set);
+const getArray = (set) => [...set];
 
 /**
- * @param {SortableSet<Chunk>} chunks the chunks
+ * @param {SortableChunks} chunks the chunks
  * @returns {RuntimeSpecSet} runtimes
  */
-const getModuleRuntimes = chunks => {
+const getModuleRuntimes = (chunks) => {
 	const runtimes = new RuntimeSpecSet();
 	for (const chunk of chunks) {
 		runtimes.add(chunk.runtime);
@@ -91,11 +94,11 @@ const getModuleRuntimes = chunks => {
 };
 
 /**
- * @param {WeakMap<Module, Set<string>> | undefined} sourceTypesByModule sourceTypesByModule
- * @returns {function (SortableSet<Module>): Map<string, SortableSet<Module>>} modules by source type
+ * @param {SourceTypesByModule | undefined} sourceTypesByModule sourceTypesByModule
+ * @returns {(set: SortableSet<Module>) => Map<string, SortableSet<Module>>} modules by source type
  */
-const modulesBySourceType = sourceTypesByModule => set => {
-	/** @type {Map<string, SortableSet<Module>>} */
+const modulesBySourceType = (sourceTypesByModule) => (set) => {
+	/** @type {Map<SourceType, SortableSet<Module>>} */
 	const map = new Map();
 	for (const module of set) {
 		const sourceTypes =
@@ -121,24 +124,27 @@ const modulesBySourceType = sourceTypesByModule => set => {
 };
 const defaultModulesBySourceType = modulesBySourceType(undefined);
 
+/**
+ * @typedef {(set: SortableSet<Module>) => Module[]} ModuleSetToArrayFunction
+ */
+
 /**
  * @template T
- * @type {WeakMap<Function, any>}
+ * @type {WeakMap<ModuleComparator, ModuleSetToArrayFunction>}
  */
 const createOrderedArrayFunctionMap = new WeakMap();
 
 /**
  * @template T
- * @param {function(T, T): -1|0|1} comparator comparator function
- * @returns {SetToArrayFunction<T>} set as ordered array
+ * @param {ModuleComparator} comparator comparator function
+ * @returns {ModuleSetToArrayFunction} set as ordered array
  */
-const createOrderedArrayFunction = comparator => {
-	/** @type {SetToArrayFunction<T>} */
+const createOrderedArrayFunction = (comparator) => {
 	let fn = createOrderedArrayFunctionMap.get(comparator);
 	if (fn !== undefined) return fn;
-	fn = set => {
+	fn = (set) => {
 		set.sortWith(comparator);
-		return Array.from(set);
+		return [...set];
 	};
 	createOrderedArrayFunctionMap.set(comparator, fn);
 	return fn;
@@ -148,7 +154,7 @@ const createOrderedArrayFunction = comparator => {
  * @param {Iterable<Module>} modules the modules to get the count/size of
  * @returns {number} the size of the modules
  */
-const getModulesSize = modules => {
+const getModulesSize = (modules) => {
 	let size = 0;
 	for (const module of modules) {
 		for (const type of module.getSourceTypes()) {
@@ -162,7 +168,7 @@ const getModulesSize = modules => {
  * @param {Iterable<Module>} modules the sortable Set to get the size of
  * @returns {Record<string, number>} the sizes of the modules
  */
-const getModulesSizes = modules => {
+const getModulesSizes = (modules) => {
 	const sizes = Object.create(null);
 	for (const module of modules) {
 		for (const type of module.getSourceTypes()) {
@@ -189,13 +195,14 @@ const isAvailableChunk = (a, b) => {
 	return true;
 };
 
+/** @typedef {SortableSet<Chunk>} SortableChunks */
 /** @typedef {Set<Chunk>} EntryInChunks */
 /** @typedef {Set<Chunk>} RuntimeInChunks */
 /** @typedef {string | number} ModuleId */
 
 class ChunkGraphModule {
 	constructor() {
-		/** @type {SortableSet<Chunk>} */
+		/** @type {SortableChunks} */
 		this.chunks = new SortableSet();
 		/** @type {EntryInChunks | undefined} */
 		this.entryInChunks = undefined;
@@ -205,22 +212,25 @@ class ChunkGraphModule {
 		this.hashes = undefined;
 		/** @type {ModuleId | null} */
 		this.id = null;
-		/** @type {RuntimeSpecMap<Set<string>> | undefined} */
+		/** @type {RuntimeSpecMap<Set<string>, RuntimeRequirements> | undefined} */
 		this.runtimeRequirements = undefined;
-		/** @type {RuntimeSpecMap<string> | undefined} */
+		/** @type {RuntimeSpecMap<string, bigint> | undefined} */
 		this.graphHashes = undefined;
-		/** @type {RuntimeSpecMap<string> | undefined} */
+		/** @type {RuntimeSpecMap<string, string> | undefined} */
 		this.graphHashesWithConnections = undefined;
 	}
 }
 
+/** @typedef {WeakMap<Module, SourceTypes>} SourceTypesByModule */
+/** @typedef {Map<Module, Entrypoint>} EntryModules */
+
 class ChunkGraphChunk {
 	constructor() {
 		/** @type {SortableSet<Module>} */
 		this.modules = new SortableSet();
-		/** @type {WeakMap<Module, Set<string>> | undefined} */
+		/** @type {SourceTypesByModule | undefined} */
 		this.sourceTypesByModule = undefined;
-		/** @type {Map<Module, Entrypoint>} */
+		/** @type {EntryModules} */
 		this.entryModules = new Map();
 		/** @type {SortableSet<RuntimeModule>} */
 		this.runtimeModules = new SortableSet();
@@ -228,7 +238,7 @@ class ChunkGraphChunk {
 		this.fullHashModules = undefined;
 		/** @type {Set<RuntimeModule> | undefined} */
 		this.dependentHashModules = undefined;
-		/** @type {Set<string> | undefined} */
+		/** @type {RuntimeRequirements | undefined} */
 		this.runtimeRequirements = undefined;
 		/** @type {Set<string>} */
 		this.runtimeRequirementsInTree = new Set();
@@ -237,12 +247,19 @@ class ChunkGraphChunk {
 	}
 }
 
+/** @typedef {string | number} RuntimeId */
+/** @typedef {Record<ModuleId, string>} IdToHashMap */
+/** @typedef {Record<ChunkId, IdToHashMap>} ChunkModuleHashMap */
+/** @typedef {Record<ChunkId, ModuleId[]>} ChunkModuleIdMap */
+
+/** @typedef {(a: Module, b: Module) => -1 | 0 | 1} ModuleComparator */
+
 class ChunkGraph {
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @param {string | Hash} hashFunction the hash function to use
 	 */
-	constructor(moduleGraph, hashFunction = "md4") {
+	constructor(moduleGraph, hashFunction = DEFAULTS.HASH_FUNCTION) {
 		/**
 		 * @private
 		 * @type {WeakMap<Module, ChunkGraphModule>}
@@ -260,7 +277,7 @@ class ChunkGraph {
 		this._blockChunkGroups = new WeakMap();
 		/**
 		 * @private
-		 * @type {Map<string, string | number>}
+		 * @type {Map<string, RuntimeId>}
 		 */
 		this._runtimeIds = new Map();
 		/** @type {ModuleGraph} */
@@ -305,14 +322,14 @@ class ChunkGraph {
 	 */
 	_getGraphRoots(set) {
 		const { moduleGraph } = this;
-		return Array.from(
-			findGraphRoots(set, module => {
+		return [
+			...findGraphRoots(set, (module) => {
 				/** @type {Set<Module>} */
 				const set = new Set();
 				/**
 				 * @param {Module} module module
 				 */
-				const addDependencies = module => {
+				const addDependencies = (module) => {
 					for (const connection of moduleGraph.getOutgoingConnections(module)) {
 						if (!connection.module) continue;
 						const activeState = connection.getActiveState(undefined);
@@ -327,7 +344,7 @@ class ChunkGraph {
 				addDependencies(module);
 				return set;
 			})
-		).sort(compareModulesByIdentifier);
+		].sort(compareModulesByIdentifier);
 	}
 
 	/**
@@ -415,8 +432,9 @@ class ChunkGraph {
 	 */
 	attachDependentHashModules(chunk, modules) {
 		const cgc = this._getChunkGraphChunk(chunk);
-		if (cgc.dependentHashModules === undefined)
+		if (cgc.dependentHashModules === undefined) {
 			cgc.dependentHashModules = new Set();
+		}
 		for (const module of modules) {
 			cgc.dependentHashModules.add(module);
 		}
@@ -446,7 +464,7 @@ class ChunkGraph {
 			for (const chunk of oldCgm.entryInChunks) {
 				const cgc = this._getChunkGraphChunk(chunk);
 				const old = /** @type {Entrypoint} */ (cgc.entryModules.get(oldModule));
-				/** @type {Map<Module, Entrypoint>} */
+				/** @type {EntryModules} */
 				const newEntryModules = new Map();
 				for (const [m, cg] of cgc.entryModules) {
 					if (m === oldModule) {
@@ -535,7 +553,7 @@ class ChunkGraph {
 
 	/**
 	 * @param {Module} module the module
-	 * @param {function(Chunk, Chunk): -1|0|1} sortFn sort function
+	 * @param {(a: Chunk, b: Chunk) => -1 | 0 | 1} sortFn sort function
 	 * @returns {Iterable<Chunk>} iterable of chunks (do not modify)
 	 */
 	getOrderedModuleChunksIterable(module, sortFn) {
@@ -614,7 +632,7 @@ class ChunkGraph {
 	/**
 	 * @param {Chunk} chunk chunk
 	 * @param {Module} module chunk module
-	 * @param {Set<string>} sourceTypes source types
+	 * @param {SourceTypes} sourceTypes source types
 	 */
 	setChunkModuleSourceTypes(chunk, module, sourceTypes) {
 		const cgc = this._getChunkGraphChunk(chunk);
@@ -651,10 +669,11 @@ class ChunkGraph {
 
 	/**
 	 * @param {Module} module module
-	 * @returns {Set<string> | undefined} source types
+	 * @returns {SourceTypes | undefined} source types
 	 */
 	_getOverwrittenModuleSourceTypes(module) {
 		let newSet = false;
+		/** @type {Set<SourceType> | undefined} */
 		let sourceTypes;
 		for (const chunk of this.getModuleChunksIterable(module)) {
 			const cgc = this._getChunkGraphChunk(chunk);
@@ -662,8 +681,7 @@ class ChunkGraph {
 			const st = cgc.sourceTypesByModule.get(module);
 			if (st === undefined) return;
 			if (!sourceTypes) {
-				sourceTypes = st;
-				continue;
+				sourceTypes = /** @type {Set<SourceType>} */ (st);
 			} else if (!newSet) {
 				for (const type of st) {
 					if (!newSet) {
@@ -686,7 +704,7 @@ class ChunkGraph {
 
 	/**
 	 * @param {Chunk} chunk the chunk
-	 * @param {function(Module, Module): -1|0|1} comparator comparator function
+	 * @param {ModuleComparator} comparator comparator function
 	 * @returns {Iterable<Module>} return the modules for this chunk
 	 */
 	getOrderedChunkModulesIterable(chunk, comparator) {
@@ -698,7 +716,7 @@ class ChunkGraph {
 	/**
 	 * @param {Chunk} chunk the chunk
 	 * @param {string} sourceType source type
-	 * @param {function(Module, Module): -1|0|1} comparator comparator function
+	 * @param {ModuleComparator} comparator comparator function
 	 * @returns {Iterable<Module> | undefined} return the modules for this chunk
 	 */
 	getOrderedChunkModulesIterableBySourceType(chunk, sourceType, comparator) {
@@ -722,7 +740,7 @@ class ChunkGraph {
 
 	/**
 	 * @param {Chunk} chunk the chunk
-	 * @param {function(Module, Module): -1|0|1} comparator comparator function
+	 * @param {ModuleComparator} comparator comparator function
 	 * @returns {Module[]} return the modules for this chunk (cached, do not modify)
 	 */
 	getOrderedChunkModules(chunk, comparator) {
@@ -735,16 +753,16 @@ class ChunkGraph {
 	 * @param {Chunk} chunk the chunk
 	 * @param {ModuleFilterPredicate} filterFn function used to filter modules
 	 * @param {boolean} includeAllChunks all chunks or only async chunks
-	 * @returns {Record<string|number, (string|number)[]>} chunk to module ids object
+	 * @returns {ChunkModuleIdMap} chunk to module ids object
 	 */
 	getChunkModuleIdMap(chunk, filterFn, includeAllChunks = false) {
-		/** @type {Record<string|number, (string|number)[]>} */
+		/** @type {ChunkModuleIdMap} */
 		const chunkModuleIdMap = Object.create(null);
 
 		for (const asyncChunk of includeAllChunks
 			? chunk.getAllReferencedChunks()
 			: chunk.getAllAsyncChunks()) {
-			/** @type {(string | number)[] | undefined} */
+			/** @type {ModuleId[] | undefined} */
 			let array;
 			for (const module of this.getOrderedChunkModulesIterable(
 				asyncChunk,
@@ -769,7 +787,7 @@ class ChunkGraph {
 	 * @param {ModuleFilterPredicate} filterFn function used to filter modules
 	 * @param {number} hashLength length of the hash
 	 * @param {boolean} includeAllChunks all chunks or only async chunks
-	 * @returns {Record<string|number, Record<string|number, string>>} chunk to module id to module hash object
+	 * @returns {ChunkModuleHashMap} chunk to module id to module hash object
 	 */
 	getChunkModuleRenderedHashMap(
 		chunk,
@@ -777,11 +795,9 @@ class ChunkGraph {
 		hashLength = 0,
 		includeAllChunks = false
 	) {
-		/** @type {Record<ChunkId, Record<string|number, string>>} */
+		/** @type {ChunkModuleHashMap} */
 		const chunkModuleHashMap = Object.create(null);
 
-		/** @typedef {Record<string|number, string>} IdToHashMap  */
-
 		for (const asyncChunk of includeAllChunks
 			? chunk.getAllReferencedChunks()
 			: chunk.getAllAsyncChunks()) {
@@ -795,7 +811,8 @@ class ChunkGraph {
 					if (idToHashMap === undefined) {
 						idToHashMap = Object.create(null);
 						chunkModuleHashMap[/** @type {ChunkId} */ (asyncChunk.id)] =
-							/** @type {IdToHashMap} */ (idToHashMap);
+							/** @type {IdToHashMap} */
+							(idToHashMap);
 					}
 					const moduleId = this.getModuleId(module);
 					const hash = this.getRenderedModuleHash(module, asyncChunk.runtime);
@@ -813,7 +830,7 @@ class ChunkGraph {
 	/**
 	 * @param {Chunk} chunk the chunk
 	 * @param {ChunkFilterPredicate} filterFn function used to filter chunks
-	 * @returns {Record<string|number, boolean>} chunk map
+	 * @returns {Record<ChunkId, boolean>} chunk map
 	 */
 	getChunkConditionMap(chunk, filterFn) {
 		const map = Object.create(null);
@@ -856,7 +873,7 @@ class ChunkGraph {
 	/**
 	 * @param {Chunk} chunkA first chunk
 	 * @param {Chunk} chunkB second chunk
-	 * @returns {-1|0|1} this is a comparator function like sort and returns -1, 0, or 1 based on sort order
+	 * @returns {-1 | 0 | 1} this is a comparator function like sort and returns -1, 0, or 1 based on sort order
 	 */
 	compareChunks(chunkA, chunkB) {
 		const cgcA = this._getChunkGraphChunk(chunkA);
@@ -1017,9 +1034,10 @@ class ChunkGraph {
 			this.connectChunkAndModule(chunkA, module);
 		}
 
-		for (const [module, chunkGroup] of Array.from(
-			this.getChunkEntryModulesWithChunkGroupIterable(chunkB)
-		)) {
+		for (const [
+			module,
+			chunkGroup
+		] of this.getChunkEntryModulesWithChunkGroupIterable(chunkB)) {
 			this.disconnectChunkAndEntryModule(chunkB, module);
 			this.connectChunkAndEntryModule(
 				chunkA,
@@ -1113,8 +1131,9 @@ class ChunkGraph {
 	 */
 	addDependentHashModuleToChunk(chunk, module) {
 		const cgc = this._getChunkGraphChunk(chunk);
-		if (cgc.dependentHashModules === undefined)
+		if (cgc.dependentHashModules === undefined) {
 			cgc.dependentHashModules = new Set();
+		}
 		cgc.dependentHashModules.add(module);
 	}
 
@@ -1212,7 +1231,7 @@ class ChunkGraph {
 	 * @returns {Iterable<Chunk>} iterable of chunks
 	 */
 	getChunkEntryDependentChunksIterable(chunk) {
-		/** @type {Set<Chunk>} */
+		/** @type {Chunks} */
 		const set = new Set();
 		for (const chunkGroup of chunk.groupsIterable) {
 			if (chunkGroup instanceof Entrypoint) {
@@ -1231,6 +1250,60 @@ class ChunkGraph {
 		return set;
 	}
 
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {Iterable<Chunk>} iterable of chunks and include chunks from children entrypoints
+	 */
+	getRuntimeChunkDependentChunksIterable(chunk) {
+		/** @type {Chunks} */
+		const set = new Set();
+
+		/** @type {Entrypoints} */
+		const entrypoints = new Set();
+
+		for (const chunkGroup of chunk.groupsIterable) {
+			if (chunkGroup instanceof Entrypoint) {
+				const queue = [chunkGroup];
+				while (queue.length > 0) {
+					const current = queue.shift();
+					if (current) {
+						entrypoints.add(current);
+
+						let hasChildrenEntrypoint = false;
+						for (const child of current.childrenIterable) {
+							if (child instanceof Entrypoint && child.dependOn(current)) {
+								hasChildrenEntrypoint = true;
+								queue.push(/** @type {Entrypoint} */ (child));
+							}
+						}
+						// entryChunkB: hasChildrenEntrypoint = true
+						// entryChunkA: dependOn = entryChunkB
+						if (hasChildrenEntrypoint) {
+							const entrypointChunk = current.getEntrypointChunk();
+							if (entrypointChunk !== chunk && !entrypointChunk.hasRuntime()) {
+								// add entryChunkB to set
+								set.add(entrypointChunk);
+							}
+						}
+					}
+				}
+			}
+		}
+
+		for (const entrypoint of entrypoints) {
+			const entrypointChunk = entrypoint.getEntrypointChunk();
+			const cgc = this._getChunkGraphChunk(entrypointChunk);
+			for (const chunkGroup of cgc.entryModules.values()) {
+				for (const c of chunkGroup.chunks) {
+					if (c !== chunk && c !== entrypointChunk && !c.hasRuntime()) {
+						set.add(c);
+					}
+				}
+			}
+		}
+		return set;
+	}
+
 	/**
 	 * @param {Chunk} chunk the chunk
 	 * @returns {boolean} true, when it has dependent chunks
@@ -1262,10 +1335,13 @@ class ChunkGraph {
 	 */
 	getChunkRuntimeModulesInOrder(chunk) {
 		const cgc = this._getChunkGraphChunk(chunk);
-		const array = Array.from(cgc.runtimeModules);
+		const array = [...cgc.runtimeModules];
 		array.sort(
 			concatComparators(
-				compareSelect(r => /** @type {RuntimeModule} */ (r).stage, compareIds),
+				compareSelect(
+					(r) => /** @type {RuntimeModule} */ (r).stage,
+					compareIds
+				),
 				compareModulesByIdentifier
 			)
 		);
@@ -1359,15 +1435,15 @@ class ChunkGraph {
 
 	/**
 	 * @param {string} runtime runtime
-	 * @returns {string | number} the id of the runtime
+	 * @returns {RuntimeId} the id of the runtime
 	 */
 	getRuntimeId(runtime) {
-		return /** @type {string | number} */ (this._runtimeIds.get(runtime));
+		return /** @type {RuntimeId} */ (this._runtimeIds.get(runtime));
 	}
 
 	/**
 	 * @param {string} runtime runtime
-	 * @param {string | number} id the id of the runtime
+	 * @param {RuntimeId} id the id of the runtime
 	 * @returns {void}
 	 */
 	setRuntimeId(runtime, id) {
@@ -1394,7 +1470,7 @@ class ChunkGraph {
 				throw new Error(
 					`No unique hash info entry for unspecified runtime for ${module.identifier()} (existing runtimes: ${Array.from(
 						hashes.keys(),
-						r => runtimeToString(r)
+						(r) => runtimeToString(r)
 					).join(", ")}).
 Caller might not support runtime-dependent code generation (opt-out via optimization.usedExports: "global").`
 				);
@@ -1467,7 +1543,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 	/**
 	 * @param {Module} module the module
 	 * @param {RuntimeSpec} runtime the runtime
-	 * @param {Set<string>} items runtime requirements to be added (ownership of this Set is given to ChunkGraph when transferOwnership not false)
+	 * @param {RuntimeRequirements} items runtime requirements to be added (ownership of this Set is given to ChunkGraph when transferOwnership not false)
 	 * @param {boolean} transferOwnership true: transfer ownership of the items object, false: items is immutable and shared and won't be modified
 	 * @returns {void}
 	 */
@@ -1486,7 +1562,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 			cgm.runtimeRequirements = map;
 			return;
 		}
-		runtimeRequirementsMap.update(runtime, runtimeRequirements => {
+		runtimeRequirementsMap.update(runtime, (runtimeRequirements) => {
 			if (runtimeRequirements === undefined) {
 				return transferOwnership ? items : new Set(items);
 			} else if (!transferOwnership || runtimeRequirements.size >= items.size) {
@@ -1501,7 +1577,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 
 	/**
 	 * @param {Chunk} chunk the chunk
-	 * @param {Set<string>} items runtime requirements to be added (ownership of this Set is given to ChunkGraph)
+	 * @param {RuntimeRequirements} items runtime requirements to be added (ownership of this Set is given to ChunkGraph)
 	 * @returns {void}
 	 */
 	addChunkRuntimeRequirements(chunk, items) {
@@ -1596,7 +1672,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 				for (const type of sourceTypes) hash.update(type);
 			}
 			this.moduleGraph.getExportsInfo(module).updateHash(hash, runtime);
-			return BigInt(`0x${/** @type {string} */ (hash.digest("hex"))}`);
+			return BigInt(`0x${hash.digest("hex")}`);
 		});
 		return graphHash;
 	}
@@ -1616,7 +1692,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 		 * @param {ConnectionState} state state
 		 * @returns {"F" | "T" | "O"} result
 		 */
-		const activeStateToString = state => {
+		const activeStateToString = (state) => {
 			if (state === false) return "F";
 			if (state === true) return "T";
 			if (state === ModuleGraphConnection.TRANSITIVE_ONLY) return "O";
@@ -1642,8 +1718,9 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 				const module = connection.module;
 				stateInfo += module.getExportsType(this.moduleGraph, strict);
 				// cspell:word Tnamespace
-				if (stateInfo === "Tnamespace") activeNamespaceModules.add(module);
-				else {
+				if (stateInfo === "Tnamespace") {
+					activeNamespaceModules.add(module);
+				} else {
 					const oldModule = connectedModules.get(stateInfo);
 					if (oldModule === undefined) {
 						connectedModules.set(stateInfo, module);
@@ -1667,7 +1744,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 					let stateInfo = "";
 					forEachRuntime(
 						runtime,
-						runtime => {
+						(runtime) => {
 							const state = connection.getActiveState(runtime);
 							states.add(state);
 							stateInfo += activeStateToString(state) + runtime;
@@ -1683,17 +1760,18 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 				}
 			}
 			// cspell:word Tnamespace
-			if (activeNamespaceModules.size === 0 && connectedModules.size === 0)
+			if (activeNamespaceModules.size === 0 && connectedModules.size === 0) {
 				return graphHash;
+			}
 			const connectedModulesInOrder =
 				connectedModules.size > 1
-					? Array.from(connectedModules).sort(([a], [b]) => (a < b ? -1 : 1))
+					? [...connectedModules].sort(([a], [b]) => (a < b ? -1 : 1))
 					: connectedModules;
 			const hash = createHash(this._hashFunction);
 			/**
 			 * @param {Module} module module
 			 */
-			const addModuleToHash = module => {
+			const addModuleToHash = (module) => {
 				hash.update(
 					this._getModuleGraphHashBigInt(
 						this._getChunkGraphModule(module),
@@ -1705,25 +1783,24 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 			/**
 			 * @param {Set<Module>} modules modules
 			 */
-			const addModulesToHash = modules => {
+			const addModulesToHash = (modules) => {
 				let xor = ZERO_BIG_INT;
 				for (const m of modules) {
-					xor =
-						xor ^
-						this._getModuleGraphHashBigInt(
-							this._getChunkGraphModule(m),
-							m,
-							runtime
-						);
+					xor ^= this._getModuleGraphHashBigInt(
+						this._getChunkGraphModule(m),
+						m,
+						runtime
+					);
 				}
 				hash.update(xor.toString(16));
 			};
-			if (activeNamespaceModules.size === 1)
+			if (activeNamespaceModules.size === 1) {
 				addModuleToHash(
 					/** @type {Module} */ (activeNamespaceModules.values().next().value)
 				);
-			else if (activeNamespaceModules.size > 1)
+			} else if (activeNamespaceModules.size > 1) {
 				addModulesToHash(activeNamespaceModules);
+			}
 			for (const [stateInfo, modules] of connectedModulesInOrder) {
 				hash.update(stateInfo);
 				if (modules instanceof Set) {
@@ -1733,7 +1810,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 				}
 			}
 			hash.update(graphHash);
-			return /** @type {string} */ (hash.digest("hex"));
+			return hash.digest("hex");
 		});
 	}
 
@@ -1761,14 +1838,15 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 			 * @param {Module} module the module
 			 * @returns {ChunkGraph} the chunk graph
 			 */
-			module => {
+			(module) => {
 				const chunkGraph = chunkGraphForModuleMap.get(module);
-				if (!chunkGraph)
+				if (!chunkGraph) {
 					throw new Error(
 						`${
 							deprecateMessage
 						}: There was no ChunkGraph assigned to the Module for backward-compat (Use the new API)`
 					);
+				}
 				return chunkGraph;
 			},
 			`${deprecateMessage}: Use new ChunkGraph API`,
@@ -1812,14 +1890,15 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 			 * @param {Chunk} chunk the chunk
 			 * @returns {ChunkGraph} the chunk graph
 			 */
-			chunk => {
+			(chunk) => {
 				const chunkGraph = chunkGraphForChunkMap.get(chunk);
-				if (!chunkGraph)
+				if (!chunkGraph) {
 					throw new Error(
 						`${
 							deprecateMessage
 						}There was no ChunkGraph assigned to the Chunk for backward-compat (Use the new API)`
 					);
+				}
 				return chunkGraph;
 			},
 			`${deprecateMessage}: Use new ChunkGraph API`,