webpack 5.85.1 → 5.87.0

package/lib/optimize/RealContentHashPlugin.js

@@ -13,12 +13,18 @@ const { compareSelect, compareStrings } = require("../util/comparators");
 const createHash = require("../util/createHash");
 
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Cache").Etag} Etag */
 /** @typedef {import("../Compilation").AssetInfo} AssetInfo */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {typeof import("../util/Hash")} Hash */
 
 const EMPTY_SET = new Set();
 
+/**
+ * @template T
+ * @param {T | T[]} itemOrItems item or items
+ * @param {Set<T>} list list
+ */
 const addToList = (itemOrItems, list) => {
 	if (Array.isArray(itemOrItems)) {
 		for (const item of itemOrItems) {
@@ -61,6 +67,10 @@ const quoteMeta = str => {
 
 const cachedSourceMap = new WeakMap();
 
+/**
+ * @param {Source} source source
+ * @returns {CachedSource} cached source
+ */
 const toCachedSource = source => {
 	if (source instanceof CachedSource) {
 		return source;
@@ -72,6 +82,10 @@ const toCachedSource = source => {
 	return newSource;
 };
 
+/** @typedef {Set<string>} OwnHashes */
+/** @typedef {Set<string>} ReferencedHashes */
+/** @typedef {Set<string>} Hashes */
+
 /**
  * @typedef {Object} AssetInfoForRealContentHash
  * @property {string} name
@@ -80,11 +94,11 @@ const toCachedSource = source => {
  * @property {RawSource | undefined} newSource
  * @property {RawSource | undefined} newSourceWithoutOwn
  * @property {string} content
- * @property {Set<string>} ownHashes
- * @property {Promise} contentComputePromise
- * @property {Promise} contentComputeWithoutOwnPromise
- * @property {Set<string>} referencedHashes
- * @property {Set<string>} hashes
+ * @property {OwnHashes | undefined} ownHashes
+ * @property {Promise<void> | undefined} contentComputePromise
+ * @property {Promise<void> | undefined} contentComputeWithoutOwnPromise
+ * @property {ReferencedHashes | undefined} referencedHashes
+ * @property {Hashes} hashes
  */
 
 /**
@@ -149,27 +163,25 @@ class RealContentHashPlugin {
 					const assets = compilation.getAssets();
 					/** @type {AssetInfoForRealContentHash[]} */
 					const assetsWithInfo = [];
+					/** @type {Map<string, [AssetInfoForRealContentHash]>} */
 					const hashToAssets = new Map();
 					for (const { source, info, name } of assets) {
 						const cachedSource = toCachedSource(source);
-						const content = cachedSource.source();
-						/** @type {Set<string>} */
+						const content = /** @type {string} */ (cachedSource.source());
+						/** @type {Hashes} */
 						const hashes = new Set();
 						addToList(info.contenthash, hashes);
+						/** @type {AssetInfoForRealContentHash} */
 						const data = {
 							name,
 							info,
 							source: cachedSource,
-							/** @type {RawSource | undefined} */
 							newSource: undefined,
-							/** @type {RawSource | undefined} */
 							newSourceWithoutOwn: undefined,
 							content,
-							/** @type {Set<string>} */
 							ownHashes: undefined,
 							contentComputePromise: undefined,
 							contentComputeWithoutOwnPromise: undefined,
-							/** @type {Set<string>} */
 							referencedHashes: undefined,
 							hashes
 						};
@@ -218,11 +230,17 @@ class RealContentHashPlugin {
 								});
 						})
 					);
+					/**
+					 * @param {string} hash the hash
+					 * @returns {undefined | ReferencedHashes} the referenced hashes
+					 */
 					const getDependencies = hash => {
 						const assets = hashToAssets.get(hash);
 						if (!assets) {
 							const referencingAssets = assetsWithInfo.filter(asset =>
-								asset.referencedHashes.has(hash)
+								/** @type {ReferencedHashes} */ (asset.referencedHashes).has(
+									hash
+								)
 							);
 							const err = new WebpackError(`RealContentHashPlugin
 Some kind of unexpected caching problem occurred.
@@ -242,23 +260,36 @@ ${referencingAssets
 						}
 						const hashes = new Set();
 						for (const { referencedHashes, ownHashes } of assets) {
-							if (!ownHashes.has(hash)) {
-								for (const hash of ownHashes) {
+							if (!(/** @type {OwnHashes} */ (ownHashes).has(hash))) {
+								for (const hash of /** @type {OwnHashes} */ (ownHashes)) {
 									hashes.add(hash);
 								}
 							}
-							for (const hash of referencedHashes) {
+							for (const hash of /** @type {ReferencedHashes} */ (
+								referencedHashes
+							)) {
 								hashes.add(hash);
 							}
 						}
 						return hashes;
 					};
+					/**
+					 * @param {string} hash the hash
+					 * @returns {string} the hash info
+					 */
 					const hashInfo = hash => {
 						const assets = hashToAssets.get(hash);
-						return `${hash} (${Array.from(assets, a => a.name)})`;
+						return `${hash} (${Array.from(
+							/** @type {AssetInfoForRealContentHash[]} */ (assets),
+							a => a.name
+						)})`;
 					};
 					const hashesInOrder = new Set();
 					for (const hash of hashToAssets.keys()) {
+						/**
+						 * @param {string} hash the hash
+						 * @param {Set<string>} stack stack of hashes
+						 */
 						const add = (hash, stack) => {
 							const deps = getDependencies(hash);
 							if (!deps) return;
@@ -282,21 +313,31 @@ ${referencingAssets
 						add(hash, new Set());
 					}
 					const hashToNewHash = new Map();
+					/**
+					 * @param {AssetInfoForRealContentHash} asset asset info
+					 * @returns {Etag} etag
+					 */
 					const getEtag = asset =>
 						cacheGenerate.mergeEtags(
 							cacheGenerate.getLazyHashedEtag(asset.source),
-							Array.from(asset.referencedHashes, hash =>
-								hashToNewHash.get(hash)
+							Array.from(
+								/** @type {ReferencedHashes} */ (asset.referencedHashes),
+								hash => hashToNewHash.get(hash)
 							).join("|")
 						);
+					/**
+					 * @param {AssetInfoForRealContentHash} asset asset info
+					 * @returns {Promise<void>}
+					 */
 					const computeNewContent = asset => {
 						if (asset.contentComputePromise) return asset.contentComputePromise;
 						return (asset.contentComputePromise = (async () => {
 							if (
-								asset.ownHashes.size > 0 ||
-								Array.from(asset.referencedHashes).some(
-									hash => hashToNewHash.get(hash) !== hash
-								)
+								/** @type {OwnHashes} */ (asset.ownHashes).size > 0 ||
+								Array.from(
+									/** @type {ReferencedHashes} */
+									(asset.referencedHashes)
+								).some(hash => hashToNewHash.get(hash) !== hash)
 							) {
 								const identifier = asset.name;
 								const etag = getEtag(asset);
@@ -313,15 +354,20 @@ ${referencingAssets
 							}
 						})());
 					};
+					/**
+					 * @param {AssetInfoForRealContentHash} asset asset info
+					 * @returns {Promise<void>}
+					 */
 					const computeNewContentWithoutOwn = asset => {
 						if (asset.contentComputeWithoutOwnPromise)
 							return asset.contentComputeWithoutOwnPromise;
 						return (asset.contentComputeWithoutOwnPromise = (async () => {
 							if (
-								asset.ownHashes.size > 0 ||
-								Array.from(asset.referencedHashes).some(
-									hash => hashToNewHash.get(hash) !== hash
-								)
+								/** @type {OwnHashes} */ (asset.ownHashes).size > 0 ||
+								Array.from(
+									/** @type {ReferencedHashes} */
+									(asset.referencedHashes)
+								).some(hash => hashToNewHash.get(hash) !== hash)
 							) {
 								const identifier = asset.name + "|without-own";
 								const etag = getEtag(asset);
@@ -332,7 +378,9 @@ ${referencingAssets
 										const newContent = asset.content.replace(
 											hashRegExp,
 											hash => {
-												if (asset.ownHashes.has(hash)) {
+												if (
+													/** @type {OwnHashes} */ (asset.ownHashes).has(hash)
+												) {
 													return "";
 												}
 												return hashToNewHash.get(hash);
@@ -346,17 +394,19 @@ ${referencingAssets
 					};
 					const comparator = compareSelect(a => a.name, compareStrings);
 					for (const oldHash of hashesInOrder) {
-						const assets = hashToAssets.get(oldHash);
+						const assets =
+							/** @type {AssetInfoForRealContentHash[]} */
+							(hashToAssets.get(oldHash));
 						assets.sort(comparator);
 						await Promise.all(
 							assets.map(asset =>
-								asset.ownHashes.has(oldHash)
+								/** @type {OwnHashes} */ (asset.ownHashes).has(oldHash)
 									? computeNewContentWithoutOwn(asset)
 									: computeNewContent(asset)
 							)
 						);
 						const assetsContent = mapAndDeduplicateBuffers(assets, asset => {
-							if (asset.ownHashes.has(oldHash)) {
+							if (/** @type {OwnHashes} */ (asset.ownHashes).has(oldHash)) {
 								return asset.newSourceWithoutOwn
 									? asset.newSourceWithoutOwn.buffer()
 									: asset.source.buffer();

package/lib/optimize/RemoveParentModulesPlugin.js

@@ -9,6 +9,8 @@ const { STAGE_BASIC } = require("../OptimizationStages");
 const Queue = require("../util/Queue");
 const { intersect } = require("../util/SetHelpers");
 
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGroup")} ChunkGroup */
 /** @typedef {import("../Compiler")} Compiler */
 
 class RemoveParentModulesPlugin {
@@ -18,6 +20,10 @@ class RemoveParentModulesPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap("RemoveParentModulesPlugin", compilation => {
+			/**
+			 * @param {Iterable<Chunk>} chunks the chunks
+			 * @param {ChunkGroup[]} chunkGroups the chunk groups
+			 */
 			const handler = (chunks, chunkGroups) => {
 				const chunkGraph = compilation.chunkGraph;
 				const queue = new Queue();

package/lib/optimize/RuntimeChunkPlugin.js

@@ -5,11 +5,17 @@
 
 "use strict";
 
+/** @typedef {import("../Compilation").EntryData} EntryData */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Entrypoint")} Entrypoint */
 
 class RuntimeChunkPlugin {
 	constructor(options) {
 		this.options = {
+			/**
+			 * @param {Entrypoint} entrypoint entrypoint name
+			 * @returns {string} runtime chunk name
+			 */
 			name: entrypoint => `runtime~${entrypoint.name}`,
 			...options
 		};
@@ -26,7 +32,9 @@ class RuntimeChunkPlugin {
 				"RuntimeChunkPlugin",
 				(_, { name: entryName }) => {
 					if (entryName === undefined) return;
-					const data = compilation.entries.get(entryName);
+					const data =
+						/** @type {EntryData} */
+						(compilation.entries.get(entryName));
 					if (data.options.runtime === undefined && !data.options.dependOn) {
 						// Determine runtime chunk name
 						let name = this.options.name;

package/lib/optimize/SideEffectsFlagPlugin.js

@@ -16,6 +16,8 @@ const HarmonyExportImportedSpecifierDependency = require("../dependencies/Harmon
 const HarmonyImportSpecifierDependency = require("../dependencies/HarmonyImportSpecifierDependency");
 const formatLocation = require("../formatLocation");
 
+/** @typedef {import("estree").ModuleDeclaration} ModuleDeclaration */
+/** @typedef {import("estree").Statement} Statement */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../Module")} Module */
@@ -117,6 +119,7 @@ class SideEffectsFlagPlugin {
 					 * @returns {void}
 					 */
 					const parserHandler = parser => {
+						/** @type {undefined | Statement | ModuleDeclaration} */
 						let sideEffectsStatement;
 						parser.hooks.program.tap(PLUGIN_NAME, () => {
 							sideEffectsStatement = undefined;
@@ -258,7 +261,7 @@ class SideEffectsFlagPlugin {
 										// TODO improve for export *
 										if (isReexport && dep.name) {
 											const exportInfo = moduleGraph.getExportInfo(
-												connection.originModule,
+												/** @type {Module} */ (connection.originModule),
 												dep.name
 											);
 											exportInfo.moveTarget(
@@ -319,6 +322,12 @@ class SideEffectsFlagPlugin {
 		);
 	}
 
+	/**
+	 * @param {string} moduleName the module name
+	 * @param {undefined | boolean | string | string[]} flagValue the flag value
+	 * @param {Map<string, RegExp>} cache cache for glob to regexp
+	 * @returns {boolean | undefined} true, when the module has side effects, undefined or false when not
+	 */
 	static moduleHasSideEffects(moduleName, flagValue, cache) {
 		switch (typeof flagValue) {
 			case "undefined":

package/lib/optimize/SplitChunksPlugin.js

@@ -41,7 +41,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 /**
  * @callback ChunkFilterFunction
  * @param {Chunk} chunk
- * @returns {boolean}
+ * @returns {boolean | undefined}
  */
 
 /**
@@ -69,7 +69,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {number=} maxInitialRequests
  * @property {(string | function(PathData, AssetInfo=): string)=} filename
  * @property {string=} idHint
- * @property {string} automaticNameDelimiter
+ * @property {string=} automaticNameDelimiter
  * @property {boolean=} reuseExistingChunk
  * @property {boolean=} usedExports
  */
@@ -254,12 +254,24 @@ const compareEntries = (a, b) => {
 	return compareModuleIterables(modulesA, modulesB);
 };
 
+/**
+ * @param {Chunk} chunk the chunk
+ * @returns {boolean} true, if the chunk is an entry chunk
+ */
 const INITIAL_CHUNK_FILTER = chunk => chunk.canBeInitial();
+/**
+ * @param {Chunk} chunk the chunk
+ * @returns {boolean} true, if the chunk is an async chunk
+ */
 const ASYNC_CHUNK_FILTER = chunk => !chunk.canBeInitial();
+/**
+ * @param {Chunk} chunk the chunk
+ * @returns {boolean} always true
+ */
 const ALL_CHUNK_FILTER = chunk => true;
 
 /**
- * @param {OptimizationSplitChunksSizes} value the sizes
+ * @param {OptimizationSplitChunksSizes | undefined} value the sizes
  * @param {string[]} defaultSizeTypes the default size types
  * @returns {SplitChunksSizes} normalized representation
  */
@@ -386,8 +398,8 @@ const totalSize = sizes => {
 };
 
 /**
- * @param {false|string|Function} name the chunk name
- * @returns {GetName} a function to get the name of the chunk
+ * @param {false|string|Function|undefined} name the chunk name
+ * @returns {GetName | undefined} a function to get the name of the chunk
  */
 const normalizeName = name => {
 	if (typeof name === "string") {
@@ -412,6 +424,11 @@ const normalizeChunksFilter = chunks => {
 	if (chunks === "all") {
 		return ALL_CHUNK_FILTER;
 	}
+	if (chunks instanceof RegExp) {
+		return chunk => {
+			return chunk.name ? chunks.test(chunk.name) : false;
+		};
+	}
 	if (typeof chunks === "function") {
 		return chunks;
 	}
@@ -839,6 +856,10 @@ module.exports = class SplitChunksPlugin {
 						}
 						return key;
 					};
+					/**
+					 * @param {bigint | Chunk} key key of the chunks
+					 * @returns {string} stringified key
+					 */
 					const keyToString = key => {
 						if (typeof key === "bigint") return key.toString(16);
 						return chunkIndexMap.get(key).toString(16);
@@ -910,6 +931,10 @@ module.exports = class SplitChunksPlugin {
 					// group these set of chunks by count
 					// to allow to check less sets via isSubset
 					// (only smaller sets can be subset)
+					/**
+					 * @param {IterableIterator<Set<Chunk>>} chunkSets set of sets of chunks
+					 * @returns {Map<number, Array<Set<Chunk>>>} map of sets of chunks by count
+					 */
 					const groupChunkSetsByCount = chunkSets => {
 						/** @type {Map<number, Array<Set<Chunk>>>} */
 						const chunkSetsByCount = new Map();
@@ -1019,8 +1044,9 @@ module.exports = class SplitChunksPlugin {
 							entry = new WeakMap();
 							selectedChunksCacheByChunksSet.set(chunks, entry);
 						}
-						/** @type {SelectedChunksResult} */
-						let entry2 = entry.get(chunkFilter);
+						let entry2 =
+							/** @type {SelectedChunksResult} */
+							(entry.get(chunkFilter));
 						if (entry2 === undefined) {
 							/** @type {Chunk[]} */
 							const selectedChunks = [];
@@ -1068,11 +1094,9 @@ module.exports = class SplitChunksPlugin {
 						// Break if minimum number of chunks is not reached
 						if (selectedChunks.length < cacheGroup.minChunks) return;
 						// Determine name for split chunk
-						const name = cacheGroup.getName(
-							module,
-							selectedChunks,
-							cacheGroup.key
-						);
+						const name =
+							/** @type {string} */
+							(cacheGroup.getName(module, selectedChunks, cacheGroup.key));
 						// Check if the name is ok
 						const existingChunk = compilation.namedChunks.get(name);
 						if (existingChunk) {
@@ -1139,7 +1163,7 @@ module.exports = class SplitChunksPlugin {
 								? ` name:${name}`
 								: ` chunks:${keyToString(selectedChunksKey)}`);
 						// Add module to maps
-						let info = chunksInfoMap.get(key);
+						let info = /** @type {ChunksInfoItem} */ (chunksInfoMap.get(key));
 						if (info === undefined) {
 							chunksInfoMap.set(
 								key,
@@ -1204,7 +1228,9 @@ module.exports = class SplitChunksPlugin {
 							getExportsChunkSetsInGraph();
 							/** @type {Set<Set<Chunk> | Chunk>} */
 							const set = new Set();
-							const groupedByUsedExports = groupedByExportsMap.get(module);
+							const groupedByUsedExports =
+								/** @type {Iterable<Chunk[]>} */
+								(groupedByExportsMap.get(module));
 							for (const chunks of groupedByUsedExports) {
 								const chunksKey = getKey(chunks);
 								for (const comb of getExportsCombinations(chunksKey))
@@ -1228,7 +1254,10 @@ module.exports = class SplitChunksPlugin {
 								if (count < cacheGroup.minChunks) continue;
 								// Select chunks by configuration
 								const { chunks: selectedChunks, key: selectedChunksKey } =
-									getSelectedChunks(chunkCombination, cacheGroup.chunksFilter);
+									getSelectedChunks(
+										chunkCombination,
+										/** @type {ChunkFilterFunction} */ (cacheGroup.chunksFilter)
+									);
 
 								addModuleToChunksInfoMap(
 									cacheGroup,
@@ -1320,12 +1349,13 @@ module.exports = class SplitChunksPlugin {
 							}
 						}
 
-						const item = bestEntry;
-						chunksInfoMap.delete(bestEntryKey);
+						const item = /** @type {ChunksInfoItem} */ (bestEntry);
+						chunksInfoMap.delete(/** @type {string} */ (bestEntryKey));
 
+						/** @type {Chunk["name"] | undefined} */
 						let chunkName = item.name;
 						// Variable for the new chunk (lazy created)
-						/** @type {Chunk} */
+						/** @type {Chunk | undefined} */
 						let newChunk;
 						// When no chunk name, check if we can reuse a chunk instead of creating a new one
 						let isExistingChunk = false;
@@ -1394,14 +1424,18 @@ module.exports = class SplitChunksPlugin {
 						) {
 							for (const chunk of usedChunks) {
 								// respect max requests
-								const maxRequests = chunk.isOnlyInitial()
-									? item.cacheGroup.maxInitialRequests
-									: chunk.canBeInitial()
-									? Math.min(
-											item.cacheGroup.maxInitialRequests,
-											item.cacheGroup.maxAsyncRequests
-									  )
-									: item.cacheGroup.maxAsyncRequests;
+								const maxRequests = /** @type {number} */ (
+									chunk.isOnlyInitial()
+										? item.cacheGroup.maxInitialRequests
+										: chunk.canBeInitial()
+										? Math.min(
+												/** @type {number} */
+												(item.cacheGroup.maxInitialRequests),
+												/** @type {number} */
+												(item.cacheGroup.maxAsyncRequests)
+										  )
+										: item.cacheGroup.maxAsyncRequests
+								);
 								if (
 									isFinite(maxRequests) &&
 									getRequests(chunk) >= maxRequests
@@ -1421,8 +1455,12 @@ module.exports = class SplitChunksPlugin {
 						// Were some (invalid) chunks removed from usedChunks?
 						// => readd all modules to the queue, as things could have been changed
 						if (usedChunks.size < item.chunks.size) {
-							if (isExistingChunk) usedChunks.add(newChunk);
-							if (usedChunks.size >= item.cacheGroup.minChunks) {
+							if (isExistingChunk)
+								usedChunks.add(/** @type {Chunk} */ (newChunk));
+							if (
+								/** @type {number} */ (usedChunks.size) >=
+								/** @type {number} */ (item.cacheGroup.minChunks)
+							) {
 								const chunksArr = Array.from(usedChunks);
 								for (const module of item.modules) {
 									addModuleToChunksInfoMap(
@@ -1466,7 +1504,7 @@ module.exports = class SplitChunksPlugin {
 								) {
 									// queue this item again to be processed again
 									// without violating modules
-									chunksInfoMap.set(bestEntryKey, item);
+									chunksInfoMap.set(/** @type {string} */ (bestEntryKey), item);
 								}
 								continue;
 							}
@@ -1696,7 +1734,9 @@ module.exports = class SplitChunksPlugin {
 									hashFilename(name, outputOptions);
 							}
 							if (i !== results.length - 1) {
-								const newPart = compilation.addChunk(name);
+								const newPart = compilation.addChunk(
+									/** @type {Chunk["name"]} */ (name)
+								);
 								chunk.split(newPart);
 								newPart.chunkReason = chunk.chunkReason;
 								// Add all modules to the new chunk
@@ -1711,7 +1751,7 @@ module.exports = class SplitChunksPlugin {
 								}
 							} else {
 								// change the chunk to be a part
-								chunk.name = name;
+								chunk.name = /** @type {Chunk["name"]} */ (name);
 							}
 						}
 					}

package/lib/performance/SizeLimitsPlugin.js

@@ -95,7 +95,7 @@ module.exports = class SizeLimitsPlugin {
 				}
 
 				const size = info.size || source.size();
-				if (size > assetSizeLimit) {
+				if (size > /** @type {number} */ (assetSizeLimit)) {
 					assetsOverSizeLimit.push({
 						name,
 						size
@@ -114,7 +114,7 @@ module.exports = class SizeLimitsPlugin {
 			for (const [name, entry] of compilation.entrypoints) {
 				const size = getEntrypointSize(entry);
 
-				if (size > entrypointSizeLimit) {
+				if (size > /** @type {number} */ (entrypointSizeLimit)) {
 					entrypointsOverLimit.push({
 						name: name,
 						size: size,
@@ -131,14 +131,17 @@ module.exports = class SizeLimitsPlugin {
 				// if !1, then 2, if !2 return
 				if (assetsOverSizeLimit.length > 0) {
 					warnings.push(
-						new AssetsOverSizeLimitWarning(assetsOverSizeLimit, assetSizeLimit)
+						new AssetsOverSizeLimitWarning(
+							assetsOverSizeLimit,
+							/** @type {number} */ (assetSizeLimit)
+						)
 					);
 				}
 				if (entrypointsOverLimit.length > 0) {
 					warnings.push(
 						new EntrypointsOverSizeLimitWarning(
 							entrypointsOverLimit,
-							entrypointSizeLimit
+							/** @type {number} */ (entrypointSizeLimit)
 						)
 					);
 				}

package/lib/prefetch/ChunkPrefetchFunctionRuntimeModule.js

@@ -7,6 +7,7 @@
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
+/** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 
 class ChunkPrefetchFunctionRuntimeModule extends RuntimeModule {
@@ -27,7 +28,8 @@ class ChunkPrefetchFunctionRuntimeModule extends RuntimeModule {
 	 */
 	generate() {
 		const { runtimeFunction, runtimeHandlers } = this;
-		const { runtimeTemplate } = this.compilation;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
 		return Template.asString([
 			`${runtimeHandlers} = {};`,
 			`${runtimeFunction} = ${runtimeTemplate.basicFunction("chunkId", [

package/lib/prefetch/ChunkPrefetchPreloadPlugin.js

@@ -11,6 +11,8 @@ const ChunkPrefetchStartupRuntimeModule = require("./ChunkPrefetchStartupRuntime
 const ChunkPrefetchTriggerRuntimeModule = require("./ChunkPrefetchTriggerRuntimeModule");
 const ChunkPreloadTriggerRuntimeModule = require("./ChunkPreloadTriggerRuntimeModule");
 
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGroup").RawChunkGroupOptions} RawChunkGroupOptions */
 /** @typedef {import("../Compiler")} Compiler */
 
 class ChunkPrefetchPreloadPlugin {
@@ -43,7 +45,7 @@ class ChunkPrefetchPreloadPlugin {
 				compilation.hooks.additionalTreeRuntimeRequirements.tap(
 					"ChunkPrefetchPreloadPlugin",
 					(chunk, set, { chunkGraph }) => {
-						const chunkMap = chunk.getChildIdsByOrdersMap(chunkGraph, false);
+						const chunkMap = chunk.getChildIdsByOrdersMap(chunkGraph);
 
 						if (chunkMap.prefetch) {
 							set.add(RuntimeGlobals.prefetchChunk);

package/lib/prefetch/ChunkPrefetchStartupRuntimeModule.js

@@ -9,6 +9,7 @@ const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 
 class ChunkPrefetchStartupRuntimeModule extends RuntimeModule {
@@ -24,8 +25,10 @@ class ChunkPrefetchStartupRuntimeModule extends RuntimeModule {
 	 * @returns {string} runtime code
 	 */
 	generate() {
-		const { startupChunks, chunk } = this;
-		const { runtimeTemplate } = this.compilation;
+		const { startupChunks } = this;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const chunk = /** @type {Chunk} */ (this.chunk);
+		const { runtimeTemplate } = compilation;
 		return Template.asString(
 			startupChunks.map(
 				({ onChunks, chunks }) =>

package/lib/prefetch/ChunkPrefetchTriggerRuntimeModule.js

@@ -8,6 +8,7 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
+/** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 
 class ChunkPrefetchTriggerRuntimeModule extends RuntimeModule {
@@ -24,7 +25,8 @@ class ChunkPrefetchTriggerRuntimeModule extends RuntimeModule {
 	 */
 	generate() {
 		const { chunkMap } = this;
-		const { runtimeTemplate } = this.compilation;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
 		const body = [
 			"var chunks = chunkToChildrenMap[chunkId];",
 			`Array.isArray(chunks) && chunks.map(${RuntimeGlobals.prefetchChunk});`