webpack 5.59.0 → 5.94.0

package/lib/ChunkGraph.js

@@ -30,9 +30,11 @@ const {
 
 /** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
 /** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./Chunk").ChunkId} ChunkId */
 /** @typedef {import("./ChunkGroup")} ChunkGroup */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
+/** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @typedef {import("./RuntimeModule")} RuntimeModule */
 /** @typedef {typeof import("./util/Hash")} Hash */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
@@ -46,14 +48,19 @@ const compareModuleIterables = compareIterables(compareModulesByIdentifier);
 
 /** @typedef {(c: Chunk, chunkGraph: ChunkGraph) => boolean} ChunkFilterPredicate */
 /** @typedef {(m: Module) => boolean} ModuleFilterPredicate */
+/** @typedef {[Module, Entrypoint | undefined]} EntryModuleWithChunkGroup */
 
 /**
- * @typedef {Object} ChunkSizeOptions
+ * @typedef {object} ChunkSizeOptions
  * @property {number=} chunkOverhead constant overhead for a chunk
  * @property {number=} entryChunkMultiplicator multiplicator for initial chunks
  */
 
 class ModuleHashInfo {
+	/**
+	 * @param {string} hash hash
+	 * @param {string} renderedHash  rendered hash
+	 */
 	constructor(hash, renderedHash) {
 		this.hash = hash;
 		this.renderedHash = renderedHash;
@@ -67,9 +74,7 @@ class ModuleHashInfo {
  * @param {SortableSet<T>} set the set
  * @returns {T[]} set as array
  */
-const getArray = set => {
-	return Array.from(set);
-};
+const getArray = set => Array.from(set);
 
 /**
  * @param {SortableSet<Chunk>} chunks the chunks
@@ -84,14 +89,17 @@ const getModuleRuntimes = chunks => {
 };
 
 /**
- * @param {SortableSet<Module>} set the set
- * @returns {Map<string, SortableSet<Module>>} modules by source type
+ * @param {WeakMap<Module, Set<string>> | undefined} sourceTypesByModule sourceTypesByModule
+ * @returns {function (SortableSet<Module>): Map<string, SortableSet<Module>>} modules by source type
  */
-const modulesBySourceType = set => {
+const modulesBySourceType = sourceTypesByModule => set => {
 	/** @type {Map<string, SortableSet<Module>>} */
 	const map = new Map();
 	for (const module of set) {
-		for (const sourceType of module.getSourceTypes()) {
+		const sourceTypes =
+			(sourceTypesByModule && sourceTypesByModule.get(module)) ||
+			module.getSourceTypes();
+		for (const sourceType of sourceTypes) {
 			let innerSet = map.get(sourceType);
 			if (innerSet === undefined) {
 				innerSet = new SortableSet();
@@ -109,6 +117,7 @@ const modulesBySourceType = set => {
 	}
 	return map;
 };
+const defaultModulesBySourceType = modulesBySourceType(undefined);
 
 /** @type {WeakMap<Function, any>} */
 const createOrderedArrayFunctionMap = new WeakMap();
@@ -149,7 +158,7 @@ const getModulesSize = modules => {
  * @returns {Record<string, number>} the sizes of the modules
  */
 const getModulesSizes = modules => {
-	let sizes = Object.create(null);
+	const sizes = Object.create(null);
 	for (const module of modules) {
 		for (const type of module.getSourceTypes()) {
 			sizes[type] = (sizes[type] || 0) + module.size(type);
@@ -175,23 +184,27 @@ const isAvailableChunk = (a, b) => {
 	return true;
 };
 
+/** @typedef {Set<Chunk>} EntryInChunks */
+/** @typedef {Set<Chunk>} RuntimeInChunks */
+/** @typedef {string | number} ModuleId */
+
 class ChunkGraphModule {
 	constructor() {
 		/** @type {SortableSet<Chunk>} */
 		this.chunks = new SortableSet();
-		/** @type {Set<Chunk> | undefined} */
+		/** @type {EntryInChunks | undefined} */
 		this.entryInChunks = undefined;
-		/** @type {Set<Chunk> | undefined} */
+		/** @type {RuntimeInChunks | undefined} */
 		this.runtimeInChunks = undefined;
-		/** @type {RuntimeSpecMap<ModuleHashInfo>} */
+		/** @type {RuntimeSpecMap<ModuleHashInfo> | undefined} */
 		this.hashes = undefined;
-		/** @type {string | number} */
+		/** @type {ModuleId | null} */
 		this.id = null;
 		/** @type {RuntimeSpecMap<Set<string>> | undefined} */
 		this.runtimeRequirements = undefined;
-		/** @type {RuntimeSpecMap<string>} */
+		/** @type {RuntimeSpecMap<string> | undefined} */
 		this.graphHashes = undefined;
-		/** @type {RuntimeSpecMap<string>} */
+		/** @type {RuntimeSpecMap<string> | undefined} */
 		this.graphHashesWithConnections = undefined;
 	}
 }
@@ -200,6 +213,8 @@ class ChunkGraphChunk {
 	constructor() {
 		/** @type {SortableSet<Module>} */
 		this.modules = new SortableSet();
+		/** @type {WeakMap<Module, Set<string>> | undefined} */
+		this.sourceTypesByModule = undefined;
 		/** @type {Map<Module, Entrypoint>} */
 		this.entryModules = new Map();
 		/** @type {SortableSet<RuntimeModule>} */
@@ -212,6 +227,8 @@ class ChunkGraphChunk {
 		this.runtimeRequirements = undefined;
 		/** @type {Set<string>} */
 		this.runtimeRequirementsInTree = new Set();
+
+		this._modulesBySourceType = defaultModulesBySourceType;
 	}
 }
 
@@ -221,13 +238,25 @@ class ChunkGraph {
 	 * @param {string | Hash} hashFunction the hash function to use
 	 */
 	constructor(moduleGraph, hashFunction = "md4") {
-		/** @private @type {WeakMap<Module, ChunkGraphModule>} */
+		/**
+		 * @private
+		 * @type {WeakMap<Module, ChunkGraphModule>}
+		 */
 		this._modules = new WeakMap();
-		/** @private @type {WeakMap<Chunk, ChunkGraphChunk>} */
+		/**
+		 * @private
+		 * @type {WeakMap<Chunk, ChunkGraphChunk>}
+		 */
 		this._chunks = new WeakMap();
-		/** @private @type {WeakMap<AsyncDependenciesBlock, ChunkGroup>} */
+		/**
+		 * @private
+		 * @type {WeakMap<AsyncDependenciesBlock, ChunkGroup>}
+		 */
 		this._blockChunkGroups = new WeakMap();
-		/** @private @type {Map<string, string | number>} */
+		/**
+		 * @private
+		 * @type {Map<string, string | number>}
+		 */
 		this._runtimeIds = new Map();
 		/** @type {ModuleGraph} */
 		this.moduleGraph = moduleGraph;
@@ -275,6 +304,9 @@ class ChunkGraph {
 			findGraphRoots(set, module => {
 				/** @type {Set<Module>} */
 				const set = new Set();
+				/**
+				 * @param {Module} module module
+				 */
 				const addDependencies = module => {
 					for (const connection of moduleGraph.getOutgoingConnections(module)) {
 						if (!connection.module) continue;
@@ -314,6 +346,8 @@ class ChunkGraph {
 		const cgm = this._getChunkGraphModule(module);
 		const cgc = this._getChunkGraphChunk(chunk);
 		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);
 	}
 
@@ -406,7 +440,7 @@ class ChunkGraph {
 			}
 			for (const chunk of oldCgm.entryInChunks) {
 				const cgc = this._getChunkGraphChunk(chunk);
-				const old = cgc.entryModules.get(oldModule);
+				const old = /** @type {Entrypoint} */ (cgc.entryModules.get(oldModule));
 				/** @type {Map<Module, Entrypoint>} */
 				const newEntryModules = new Map();
 				for (const [m, cg] of cgc.entryModules) {
@@ -567,11 +601,84 @@ class ChunkGraph {
 	getChunkModulesIterableBySourceType(chunk, sourceType) {
 		const cgc = this._getChunkGraphChunk(chunk);
 		const modulesWithSourceType = cgc.modules
-			.getFromUnorderedCache(modulesBySourceType)
+			.getFromUnorderedCache(cgc._modulesBySourceType)
 			.get(sourceType);
 		return modulesWithSourceType;
 	}
 
+	/**
+	 * @param {Chunk} chunk chunk
+	 * @param {Module} module chunk module
+	 * @param {Set<string>} sourceTypes source types
+	 */
+	setChunkModuleSourceTypes(chunk, module, sourceTypes) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		if (cgc.sourceTypesByModule === undefined) {
+			cgc.sourceTypesByModule = new WeakMap();
+		}
+		cgc.sourceTypesByModule.set(module, sourceTypes);
+		// Update cgc._modulesBySourceType to invalidate the cache
+		cgc._modulesBySourceType = modulesBySourceType(cgc.sourceTypesByModule);
+	}
+
+	/**
+	 * @param {Chunk} chunk chunk
+	 * @param {Module} module chunk module
+	 * @returns {Set<string>} source types
+	 */
+	getChunkModuleSourceTypes(chunk, module) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		if (cgc.sourceTypesByModule === undefined) {
+			return module.getSourceTypes();
+		}
+		return cgc.sourceTypesByModule.get(module) || module.getSourceTypes();
+	}
+
+	/**
+	 * @param {Module} module module
+	 * @returns {Set<string>} source types
+	 */
+	getModuleSourceTypes(module) {
+		return (
+			this._getOverwrittenModuleSourceTypes(module) || module.getSourceTypes()
+		);
+	}
+
+	/**
+	 * @param {Module} module module
+	 * @returns {Set<string> | undefined} source types
+	 */
+	_getOverwrittenModuleSourceTypes(module) {
+		let newSet = false;
+		let sourceTypes;
+		for (const chunk of this.getModuleChunksIterable(module)) {
+			const cgc = this._getChunkGraphChunk(chunk);
+			if (cgc.sourceTypesByModule === undefined) return;
+			const st = cgc.sourceTypesByModule.get(module);
+			if (st === undefined) return;
+			if (!sourceTypes) {
+				sourceTypes = st;
+				continue;
+			} else if (!newSet) {
+				for (const type of st) {
+					if (!newSet) {
+						if (!sourceTypes.has(type)) {
+							newSet = true;
+							sourceTypes = new Set(sourceTypes);
+							sourceTypes.add(type);
+						}
+					} else {
+						sourceTypes.add(type);
+					}
+				}
+			} else {
+				for (const type of st) sourceTypes.add(type);
+			}
+		}
+
+		return sourceTypes;
+	}
+
 	/**
 	 * @param {Chunk} chunk the chunk
 	 * @param {function(Module, Module): -1|0|1} comparator comparator function
@@ -592,9 +699,9 @@ class ChunkGraph {
 	getOrderedChunkModulesIterableBySourceType(chunk, sourceType, comparator) {
 		const cgc = this._getChunkGraphChunk(chunk);
 		const modulesWithSourceType = cgc.modules
-			.getFromUnorderedCache(modulesBySourceType)
+			.getFromUnorderedCache(cgc._modulesBySourceType)
 			.get(sourceType);
-		if (modulesWithSourceType === undefined) return undefined;
+		if (modulesWithSourceType === undefined) return;
 		modulesWithSourceType.sortWith(comparator);
 		return modulesWithSourceType;
 	}
@@ -632,7 +739,7 @@ class ChunkGraph {
 		for (const asyncChunk of includeAllChunks
 			? chunk.getAllReferencedChunks()
 			: chunk.getAllAsyncChunks()) {
-			/** @type {(string|number)[]} */
+			/** @type {(string | number)[] | undefined} */
 			let array;
 			for (const module of this.getOrderedChunkModulesIterable(
 				asyncChunk,
@@ -641,9 +748,9 @@ class ChunkGraph {
 				if (filterFn(module)) {
 					if (array === undefined) {
 						array = [];
-						chunkModuleIdMap[asyncChunk.id] = array;
+						chunkModuleIdMap[/** @type {ChunkId} */ (asyncChunk.id)] = array;
 					}
-					const moduleId = this.getModuleId(module);
+					const moduleId = /** @type {ModuleId} */ (this.getModuleId(module));
 					array.push(moduleId);
 				}
 			}
@@ -665,13 +772,15 @@ class ChunkGraph {
 		hashLength = 0,
 		includeAllChunks = false
 	) {
-		/** @type {Record<string|number, Record<string|number, string>>} */
+		/** @type {Record<ChunkId, Record<string|number, string>>} */
 		const chunkModuleHashMap = Object.create(null);
 
+		/** @typedef {Record<string|number, string>} IdToHashMap  */
+
 		for (const asyncChunk of includeAllChunks
 			? chunk.getAllReferencedChunks()
 			: chunk.getAllAsyncChunks()) {
-			/** @type {Record<string|number, string>} */
+			/** @type {IdToHashMap | undefined} */
 			let idToHashMap;
 			for (const module of this.getOrderedChunkModulesIterable(
 				asyncChunk,
@@ -680,11 +789,15 @@ class ChunkGraph {
 				if (filterFn(module)) {
 					if (idToHashMap === undefined) {
 						idToHashMap = Object.create(null);
-						chunkModuleHashMap[asyncChunk.id] = idToHashMap;
+						chunkModuleHashMap[/** @type {ChunkId} */ (asyncChunk.id)] =
+							/** @type {IdToHashMap} */ (idToHashMap);
 					}
 					const moduleId = this.getModuleId(module);
 					const hash = this.getRenderedModuleHash(module, asyncChunk.runtime);
-					idToHashMap[moduleId] = hashLength ? hash.slice(0, hashLength) : hash;
+					/** @type {IdToHashMap} */
+					(idToHashMap)[/** @type {ModuleId} */ (moduleId)] = hashLength
+						? hash.slice(0, hashLength)
+						: hash;
 				}
 			}
 		}
@@ -700,7 +813,7 @@ class ChunkGraph {
 	getChunkConditionMap(chunk, filterFn) {
 		const map = Object.create(null);
 		for (const c of chunk.getAllReferencedChunks()) {
-			map[c.id] = filterFn(c, this);
+			map[/** @type {ChunkId} */ (c.id)] = filterFn(c, this);
 		}
 		return map;
 	}
@@ -808,7 +921,7 @@ class ChunkGraph {
 		const cgcB = this._getChunkGraphChunk(chunkB);
 		const allModules = new Set(cgcA.modules);
 		for (const m of cgcB.modules) allModules.add(m);
-		let modulesSize = getModulesSize(allModules);
+		const modulesSize = getModulesSize(allModules);
 		const chunkOverhead =
 			typeof options.chunkOverhead === "number" ? options.chunkOverhead : 10000;
 		const entryChunkMultiplicator =
@@ -842,9 +955,9 @@ class ChunkGraph {
 				return isAvailableChunk(chunkA, chunkB);
 			} else if (hasRuntimeB) {
 				return isAvailableChunk(chunkB, chunkA);
-			} else {
-				return false;
 			}
+
+			return false;
 		}
 
 		if (
@@ -903,7 +1016,12 @@ class ChunkGraph {
 			this.getChunkEntryModulesWithChunkGroupIterable(chunkB)
 		)) {
 			this.disconnectChunkAndEntryModule(chunkB, module);
-			this.connectChunkAndEntryModule(chunkA, module, chunkGroup);
+			this.connectChunkAndEntryModule(
+				chunkA,
+				module,
+				/** @type {Entrypoint} */
+				(chunkGroup)
+			);
 		}
 
 		for (const chunkGroup of chunkB.groupsIterable) {
@@ -944,7 +1062,7 @@ class ChunkGraph {
 	/**
 	 * @param {Chunk} chunk the new chunk
 	 * @param {Module} module the entry module
-	 * @param {Entrypoint=} entrypoint the chunk group which must be loaded before the module is executed
+	 * @param {Entrypoint} entrypoint the chunk group which must be loaded before the module is executed
 	 * @returns {void}
 	 */
 	connectChunkAndEntryModule(chunk, module, entrypoint) {
@@ -1003,8 +1121,9 @@ class ChunkGraph {
 	disconnectChunkAndEntryModule(chunk, module) {
 		const cgm = this._getChunkGraphModule(module);
 		const cgc = this._getChunkGraphChunk(chunk);
-		cgm.entryInChunks.delete(chunk);
-		if (cgm.entryInChunks.size === 0) {
+		/** @type {EntryInChunks} */
+		(cgm.entryInChunks).delete(chunk);
+		if (/** @type {EntryInChunks} */ (cgm.entryInChunks).size === 0) {
 			cgm.entryInChunks = undefined;
 		}
 		cgc.entryModules.delete(module);
@@ -1018,8 +1137,9 @@ class ChunkGraph {
 	disconnectChunkAndRuntimeModule(chunk, module) {
 		const cgm = this._getChunkGraphModule(module);
 		const cgc = this._getChunkGraphChunk(chunk);
-		cgm.runtimeInChunks.delete(chunk);
-		if (cgm.runtimeInChunks.size === 0) {
+		/** @type {RuntimeInChunks} */
+		(cgm.runtimeInChunks).delete(chunk);
+		if (/** @type {RuntimeInChunks} */ (cgm.runtimeInChunks).size === 0) {
 			cgm.runtimeInChunks = undefined;
 		}
 		cgc.runtimeModules.delete(module);
@@ -1031,7 +1151,7 @@ class ChunkGraph {
 	 */
 	disconnectEntryModule(module) {
 		const cgm = this._getChunkGraphModule(module);
-		for (const chunk of cgm.entryInChunks) {
+		for (const chunk of /** @type {EntryInChunks} */ (cgm.entryInChunks)) {
 			const cgc = this._getChunkGraphChunk(chunk);
 			cgc.entryModules.delete(module);
 		}
@@ -1046,8 +1166,9 @@ class ChunkGraph {
 		const cgc = this._getChunkGraphChunk(chunk);
 		for (const module of cgc.entryModules.keys()) {
 			const cgm = this._getChunkGraphModule(module);
-			cgm.entryInChunks.delete(chunk);
-			if (cgm.entryInChunks.size === 0) {
+			/** @type {EntryInChunks} */
+			(cgm.entryInChunks).delete(chunk);
+			if (/** @type {EntryInChunks} */ (cgm.entryInChunks).size === 0) {
 				cgm.entryInChunks = undefined;
 			}
 		}
@@ -1139,14 +1260,7 @@ class ChunkGraph {
 		const array = Array.from(cgc.runtimeModules);
 		array.sort(
 			concatComparators(
-				compareSelect(
-					/**
-					 * @param {RuntimeModule} r runtime module
-					 * @returns {number=} stage
-					 */
-					r => r.stage,
-					compareIds
-				),
+				compareSelect(r => /** @type {RuntimeModule} */ (r).stage, compareIds),
 				compareModulesByIdentifier
 			)
 		);
@@ -1180,8 +1294,6 @@ class ChunkGraph {
 		return cgc.dependentHashModules;
 	}
 
-	/** @typedef {[Module, Entrypoint | undefined]} EntryModuleWithChunkGroup */
-
 	/**
 	 * @param {Chunk} chunk the chunk
 	 * @returns {Iterable<EntryModuleWithChunkGroup>} iterable of modules (do not modify)
@@ -1193,7 +1305,7 @@ class ChunkGraph {
 
 	/**
 	 * @param {AsyncDependenciesBlock} depBlock the async block
-	 * @returns {ChunkGroup} the chunk group
+	 * @returns {ChunkGroup | undefined} the chunk group
 	 */
 	getBlockChunkGroup(depBlock) {
 		return this._blockChunkGroups.get(depBlock);
@@ -1223,7 +1335,7 @@ class ChunkGraph {
 
 	/**
 	 * @param {Module} module the module
-	 * @returns {string | number} the id of the module
+	 * @returns {ModuleId | null} the id of the module
 	 */
 	getModuleId(module) {
 		const cgm = this._getChunkGraphModule(module);
@@ -1232,7 +1344,7 @@ class ChunkGraph {
 
 	/**
 	 * @param {Module} module the module
-	 * @param {string | number} id the id of the module
+	 * @param {ModuleId} id the id of the module
 	 * @returns {void}
 	 */
 	setModuleId(module, id) {
@@ -1245,7 +1357,7 @@ class ChunkGraph {
 	 * @returns {string | number} the id of the runtime
 	 */
 	getRuntimeId(runtime) {
-		return this._runtimeIds.get(runtime);
+		return /** @type {string | number} */ (this._runtimeIds.get(runtime));
 	}
 
 	/**
@@ -1282,7 +1394,7 @@ class ChunkGraph {
 Caller might not support runtime-dependent code generation (opt-out via optimization.usedExports: "global").`
 				);
 			}
-			return first(hashInfoItems);
+			return /** @type {T} */ (first(hashInfoItems));
 		} else {
 			const hashInfo = hashes.get(runtime);
 			if (!hashInfo) {
@@ -1306,7 +1418,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 	 */
 	hasModuleHashes(module, runtime) {
 		const cgm = this._getChunkGraphModule(module);
-		const hashes = cgm.hashes;
+		const hashes = /** @type {RuntimeSpecMap<ModuleHashInfo>} */ (cgm.hashes);
 		return hashes && hashes.has(runtime);
 	}
 
@@ -1317,7 +1429,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 	 */
 	getModuleHash(module, runtime) {
 		const cgm = this._getChunkGraphModule(module);
-		const hashes = cgm.hashes;
+		const hashes = /** @type {RuntimeSpecMap<ModuleHashInfo>} */ (cgm.hashes);
 		return this._getModuleHashInfo(module, hashes, runtime).hash;
 	}
 
@@ -1328,7 +1440,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 	 */
 	getRenderedModuleHash(module, runtime) {
 		const cgm = this._getChunkGraphModule(module);
-		const hashes = cgm.hashes;
+		const hashes = /** @type {RuntimeSpecMap<ModuleHashInfo>} */ (cgm.hashes);
 		return this._getModuleHashInfo(module, hashes, runtime).renderedHash;
 	}
 
@@ -1375,10 +1487,10 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 			} else if (!transferOwnership || runtimeRequirements.size >= items.size) {
 				for (const item of items) runtimeRequirements.add(item);
 				return runtimeRequirements;
-			} else {
-				for (const item of runtimeRequirements) items.add(item);
-				return items;
 			}
+
+			for (const item of runtimeRequirements) items.add(item);
+			return items;
 		});
 	}
 
@@ -1457,7 +1569,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 		return withConnections
 			? BigInt(
 					`0x${this._getModuleGraphHashWithConnections(cgm, module, runtime)}`
-			  )
+				)
 			: this._getModuleGraphHashBigInt(cgm, module, runtime);
 	}
 
@@ -1474,6 +1586,10 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 		const graphHash = cgm.graphHashes.provide(runtime, () => {
 			const hash = createHash(this._hashFunction);
 			hash.update(`${cgm.id}${this.moduleGraph.isAsync(module)}`);
+			const sourceTypes = this._getOverwrittenModuleSourceTypes(module);
+			if (sourceTypes !== undefined) {
+				for (const type of sourceTypes) hash.update(type);
+			}
 			this.moduleGraph.getExportsInfo(module).updateHash(hash, runtime);
 			return BigInt(`0x${/** @type {string} */ (hash.digest("hex"))}`);
 		});
@@ -1490,6 +1606,11 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 		if (cgm.graphHashesWithConnections === undefined) {
 			cgm.graphHashesWithConnections = new RuntimeSpecMap();
 		}
+
+		/**
+		 * @param {ConnectionState} state state
+		 * @returns {"F" | "T" | "O"} result
+		 */
 		const activeStateToString = state => {
 			if (state === false) return "F";
 			if (state === true) return "T";
@@ -1508,6 +1629,10 @@ 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();
+			/**
+			 * @param {ModuleGraphConnection} connection connection
+			 * @param {string} stateInfo state info
+			 */
 			const processConnection = (connection, stateInfo) => {
 				const module = connection.module;
 				stateInfo += module.getExportsType(this.moduleGraph, strict);
@@ -1560,6 +1685,9 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 					? Array.from(connectedModules).sort(([a], [b]) => (a < b ? -1 : 1))
 					: connectedModules;
 			const hash = createHash(this._hashFunction);
+			/**
+			 * @param {Module} module module
+			 */
 			const addModuleToHash = module => {
 				hash.update(
 					this._getModuleGraphHashBigInt(
@@ -1569,6 +1697,9 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 					).toString(16)
 				);
 			};
+			/**
+			 * @param {Set<Module>} modules modules
+			 */
 			const addModulesToHash = modules => {
 				let xor = ZERO_BIG_INT;
 				for (const m of modules) {
@@ -1583,7 +1714,9 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 				hash.update(xor.toString(16));
 			};
 			if (activeNamespaceModules.size === 1)
-				addModuleToHash(activeNamespaceModules.values().next().value);
+				addModuleToHash(
+					/** @type {Module} */ (activeNamespaceModules.values().next().value)
+				);
 			else if (activeNamespaceModules.size > 1)
 				addModulesToHash(activeNamespaceModules);
 			for (const [stateInfo, modules] of connectedModulesInOrder) {
@@ -1627,12 +1760,13 @@ 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;
 			},
-			deprecateMessage + ": Use new ChunkGraph API",
+			`${deprecateMessage}: Use new ChunkGraph API`,
 			deprecationCode
 		);
 		deprecateGetChunkGraphForModuleMap.set(deprecateMessage, newFn);
@@ -1677,12 +1811,13 @@ 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;
 			},
-			deprecateMessage + ": Use new ChunkGraph API",
+			`${deprecateMessage}: Use new ChunkGraph API`,
 			deprecationCode
 		);
 		deprecateGetChunkGraphForChunkMap.set(deprecateMessage, newFn);