webpack 5.59.0 → 5.94.0

package/lib/optimize/SplitChunksPlugin.js

@@ -28,11 +28,10 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 /** @typedef {import("../../declarations/WebpackOptions").Output} OutputOptions */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../ChunkGroup")} ChunkGroup */
-/** @typedef {import("../Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("../Compilation").PathData} PathData */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../TemplatedPathPlugin").TemplatePath} TemplatePath */
 /** @typedef {import("../util/deterministicGrouping").GroupedItems<Module>} DeterministicGroupingGroupedItemsForModule */
 /** @typedef {import("../util/deterministicGrouping").Options<Module>} DeterministicGroupingOptionsForModule */
 
@@ -41,7 +40,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 /**
  * @callback ChunkFilterFunction
  * @param {Chunk} chunk
- * @returns {boolean}
+ * @returns {boolean | undefined}
  */
 
 /**
@@ -52,7 +51,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  */
 
 /**
- * @typedef {Object} CacheGroupSource
+ * @typedef {object} CacheGroupSource
  * @property {string=} key
  * @property {number=} priority
  * @property {GetName=} getName
@@ -67,15 +66,15 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {number=} minChunks
  * @property {number=} maxAsyncRequests
  * @property {number=} maxInitialRequests
- * @property {(string | function(PathData, AssetInfo=): string)=} filename
+ * @property {TemplatePath=} filename
  * @property {string=} idHint
- * @property {string} automaticNameDelimiter
+ * @property {string=} automaticNameDelimiter
  * @property {boolean=} reuseExistingChunk
  * @property {boolean=} usedExports
  */
 
 /**
- * @typedef {Object} CacheGroup
+ * @typedef {object} CacheGroup
  * @property {string} key
  * @property {number=} priority
  * @property {GetName=} getName
@@ -89,7 +88,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {number=} minChunks
  * @property {number=} maxAsyncRequests
  * @property {number=} maxInitialRequests
- * @property {(string | function(PathData, AssetInfo=): string)=} filename
+ * @property {TemplatePath=} filename
  * @property {string=} idHint
  * @property {string} automaticNameDelimiter
  * @property {boolean} reuseExistingChunk
@@ -101,7 +100,8 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  */
 
 /**
- * @typedef {Object} FallbackCacheGroup
+ * @typedef {object} FallbackCacheGroup
+ * @property {ChunkFilterFunction} chunksFilter
  * @property {SplitChunksSizes} minSize
  * @property {SplitChunksSizes} maxAsyncSize
  * @property {SplitChunksSizes} maxInitialSize
@@ -109,7 +109,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  */
 
 /**
- * @typedef {Object} CacheGroupsContext
+ * @typedef {object} CacheGroupsContext
  * @property {ModuleGraph} moduleGraph
  * @property {ChunkGraph} chunkGraph
  */
@@ -130,7 +130,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  */
 
 /**
- * @typedef {Object} SplitChunksOptions
+ * @typedef {object} SplitChunksOptions
  * @property {ChunkFilterFunction} chunksFilter
  * @property {string[]} defaultSizeTypes
  * @property {SplitChunksSizes} minSize
@@ -143,7 +143,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {number} maxAsyncRequests
  * @property {number} maxInitialRequests
  * @property {boolean} hidePathInfo
- * @property {string | function(PathData, AssetInfo=): string} filename
+ * @property {TemplatePath} filename
  * @property {string} automaticNameDelimiter
  * @property {GetCacheGroups} getCacheGroups
  * @property {GetName} getName
@@ -152,23 +152,22 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  */
 
 /**
- * @typedef {Object} ChunksInfoItem
+ * @typedef {object} ChunksInfoItem
  * @property {SortableSet<Module>} modules
  * @property {CacheGroup} cacheGroup
  * @property {number} cacheGroupIndex
  * @property {string} name
  * @property {Record<string, number>} sizes
  * @property {Set<Chunk>} chunks
- * @property {Set<Chunk>} reuseableChunks
+ * @property {Set<Chunk>} reusableChunks
  * @property {Set<bigint | Chunk>} chunksKeys
  */
 
 const defaultGetName = /** @type {GetName} */ (() => {});
 
 const deterministicGroupingForModules =
-	/** @type {function(DeterministicGroupingOptionsForModule): DeterministicGroupingGroupedItemsForModule[]} */ (
-		deterministicGrouping
-	);
+	/** @type {function(DeterministicGroupingOptionsForModule): DeterministicGroupingGroupedItemsForModule[]} */
+	(deterministicGrouping);
 
 /** @type {WeakMap<Module, string>} */
 const getKeyCache = new WeakMap();
@@ -179,11 +178,13 @@ const getKeyCache = new WeakMap();
  * @returns {string} hashed filename
  */
 const hashFilename = (name, outputOptions) => {
-	const digest = /** @type {string} */ (
-		createHash(outputOptions.hashFunction)
-			.update(name)
-			.digest(outputOptions.hashDigest)
-	);
+	const digest =
+		/** @type {string} */
+		(
+			createHash(outputOptions.hashFunction)
+				.update(name)
+				.digest(outputOptions.hashDigest)
+		);
 	return digest.slice(0, 8);
 };
 
@@ -199,10 +200,21 @@ const getRequests = chunk => {
 	return requests;
 };
 
+/**
+ * @template {object} T
+ * @template {object} R
+ * @param {T} obj obj an object
+ * @param {function(T[keyof T], keyof T): T[keyof T]} fn fn
+ * @returns {T} result
+ */
 const mapObject = (obj, fn) => {
 	const newObj = Object.create(null);
 	for (const key of Object.keys(obj)) {
-		newObj[key] = fn(obj[key], key);
+		newObj[key] = fn(
+			obj[/** @type {keyof T} */ (key)],
+			/** @type {keyof T} */
+			(key)
+		);
 	}
 	return newObj;
 };
@@ -253,12 +265,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
  */
@@ -270,13 +294,12 @@ const normalizeSizes = (value, defaultSizeTypes) => {
 		return o;
 	} else if (typeof value === "object" && value !== null) {
 		return { ...value };
-	} else {
-		return {};
 	}
+	return {};
 };
 
 /**
- * @param {...SplitChunksSizes} sizes the sizes
+ * @param {...(SplitChunksSizes | undefined)} sizes the sizes
  * @returns {SplitChunksSizes} the merged sizes
  */
 const mergeSizes = (...sizes) => {
@@ -311,11 +334,7 @@ const combineSizes = (a, b, combine) => {
 	/** @type {SplitChunksSizes} */
 	const result = {};
 	for (const key of aKeys) {
-		if (bKeys.has(key)) {
-			result[key] = combine(a[key], b[key]);
-		} else {
-			result[key] = a[key];
-		}
+		result[key] = bKeys.has(key) ? combine(a[key], b[key]) : a[key];
 	}
 	for (const key of bKeys) {
 		if (!aKeys.has(key)) {
@@ -385,8 +404,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") {
@@ -411,6 +430,9 @@ const normalizeChunksFilter = chunks => {
 	if (chunks === "all") {
 		return ALL_CHUNK_FILTER;
 	}
+	if (chunks instanceof RegExp) {
+		return chunk => (chunk.name ? chunks.test(chunk.name) : false);
+	}
 	if (typeof chunks === "function") {
 		return chunks;
 	}
@@ -482,7 +504,7 @@ const normalizeCacheGroups = (cacheGroups, defaultSizeTypes) => {
 		 */
 		const fn = (module, context) => {
 			/** @type {CacheGroupSource[]} */
-			let results = [];
+			const results = [];
 			for (const fn of handlers) {
 				fn(module, context, results);
 			}
@@ -658,6 +680,9 @@ module.exports = class SplitChunksPlugin {
 			automaticNameDelimiter: options.automaticNameDelimiter,
 			usedExports: options.usedExports,
 			fallbackCacheGroup: {
+				chunksFilter: normalizeChunksFilter(
+					fallbackCacheGroup.chunks || options.chunks || "all"
+				),
 				minSize: mergeSizes(
 					normalizeSizes(fallbackCacheGroup.minSize, defaultSizeTypes),
 					minSize
@@ -728,20 +753,20 @@ module.exports = class SplitChunksPlugin {
 				cacheGroupSource.minChunks !== undefined
 					? cacheGroupSource.minChunks
 					: cacheGroupSource.enforce
-					? 1
-					: this.options.minChunks,
+						? 1
+						: this.options.minChunks,
 			maxAsyncRequests:
 				cacheGroupSource.maxAsyncRequests !== undefined
 					? cacheGroupSource.maxAsyncRequests
 					: cacheGroupSource.enforce
-					? Infinity
-					: this.options.maxAsyncRequests,
+						? Infinity
+						: this.options.maxAsyncRequests,
 			maxInitialRequests:
 				cacheGroupSource.maxInitialRequests !== undefined
 					? cacheGroupSource.maxInitialRequests
 					: cacheGroupSource.enforce
-					? Infinity
-					: this.options.maxInitialRequests,
+						? Infinity
+						: this.options.maxInitialRequests,
 			getName:
 				cacheGroupSource.getName !== undefined
 					? cacheGroupSource.getName
@@ -835,6 +860,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);
@@ -906,6 +935,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();
@@ -994,7 +1027,7 @@ module.exports = class SplitChunksPlugin {
 						getExportsCombinationsFactory()(key);
 
 					/**
-					 * @typedef {Object} SelectedChunksResult
+					 * @typedef {object} SelectedChunksResult
 					 * @property {Chunk[]} chunks the list of chunks
 					 * @property {bigint | Chunk} key a key of the list
 					 */
@@ -1015,8 +1048,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 = [];
@@ -1064,11 +1098,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) {
@@ -1135,7 +1167,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,
@@ -1149,7 +1181,7 @@ module.exports = class SplitChunksPlugin {
 									name,
 									sizes: {},
 									chunks: new Set(),
-									reuseableChunks: new Set(),
+									reusableChunks: new Set(),
 									chunksKeys: new Set()
 								})
 							);
@@ -1182,7 +1214,7 @@ module.exports = class SplitChunksPlugin {
 					// Walk through all modules
 					for (const module of compilation.modules) {
 						// Get cache group
-						let cacheGroups = this.options.getCacheGroups(module, context);
+						const cacheGroups = this.options.getCacheGroups(module, context);
 						if (!Array.isArray(cacheGroups) || cacheGroups.length === 0) {
 							continue;
 						}
@@ -1200,7 +1232,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))
@@ -1224,7 +1258,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,
@@ -1289,7 +1326,7 @@ module.exports = class SplitChunksPlugin {
 					}
 
 					/**
-					 * @typedef {Object} MaxSizeQueueItem
+					 * @typedef {object} MaxSizeQueueItem
 					 * @property {SplitChunksSizes} minSize
 					 * @property {SplitChunksSizes} maxAsyncSize
 					 * @property {SplitChunksSizes} maxInitialSize
@@ -1316,12 +1353,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;
@@ -1390,16 +1428,20 @@ 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) &&
+									Number.isFinite(maxRequests) &&
 									getRequests(chunk) >= maxRequests
 								) {
 									usedChunks.delete(chunk);
@@ -1417,8 +1459,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(
@@ -1440,7 +1486,7 @@ module.exports = class SplitChunksPlugin {
 							usedChunks.size === 1
 						) {
 							const [chunk] = usedChunks;
-							let chunkSizes = Object.create(null);
+							const chunkSizes = Object.create(null);
 							for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
 								if (!item.modules.has(module)) {
 									for (const type of module.getSourceTypes()) {
@@ -1462,7 +1508,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;
 							}
@@ -1480,7 +1526,7 @@ module.exports = class SplitChunksPlugin {
 
 						// Add a note to the chunk
 						newChunk.chunkReason =
-							(newChunk.chunkReason ? newChunk.chunkReason + ", " : "") +
+							(newChunk.chunkReason ? `${newChunk.chunkReason}, ` : "") +
 							(isReusedWithAllModules
 								? "reused as split chunk"
 								: "split chunk");
@@ -1527,21 +1573,21 @@ module.exports = class SplitChunksPlugin {
 											oldMaxSizeSettings.minSize,
 											item.cacheGroup._minSizeForMaxSize,
 											Math.max
-									  )
+										)
 									: item.cacheGroup.minSize,
 								maxAsyncSize: oldMaxSizeSettings
 									? combineSizes(
 											oldMaxSizeSettings.maxAsyncSize,
 											item.cacheGroup.maxAsyncSize,
 											Math.min
-									  )
+										)
 									: item.cacheGroup.maxAsyncSize,
 								maxInitialSize: oldMaxSizeSettings
 									? combineSizes(
 											oldMaxSizeSettings.maxInitialSize,
 											item.cacheGroup.maxInitialSize,
 											Math.min
-									  )
+										)
 									: item.cacheGroup.maxInitialSize,
 								automaticNameDelimiter: item.cacheGroup.automaticNameDelimiter,
 								keys: oldMaxSizeSettings
@@ -1598,6 +1644,7 @@ module.exports = class SplitChunksPlugin {
 					const { outputOptions } = compilation;
 
 					// Make sure that maxSize is fulfilled
+					const { fallbackCacheGroup } = this.options;
 					for (const chunk of Array.from(compilation.chunks)) {
 						const chunkConfig = maxSizeQueueMap.get(chunk);
 						const {
@@ -1605,7 +1652,9 @@ module.exports = class SplitChunksPlugin {
 							maxAsyncSize,
 							maxInitialSize,
 							automaticNameDelimiter
-						} = chunkConfig || this.options.fallbackCacheGroup;
+						} = chunkConfig || fallbackCacheGroup;
+						if (!chunkConfig && !fallbackCacheGroup.chunksFilter(chunk))
+							continue;
 						/** @type {SplitChunksSizes} */
 						let maxSize;
 						if (chunk.isOnlyInitial()) {
@@ -1689,7 +1738,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
@@ -1704,7 +1755,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

@@ -13,18 +13,19 @@ const NoAsyncChunksWarning = require("./NoAsyncChunksWarning");
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../../declarations/WebpackOptions").PerformanceOptions} PerformanceOptions */
 /** @typedef {import("../ChunkGroup")} ChunkGroup */
+/** @typedef {import("../Compilation").Asset} Asset */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Entrypoint")} Entrypoint */
 /** @typedef {import("../WebpackError")} WebpackError */
 
 /**
- * @typedef {Object} AssetDetails
+ * @typedef {object} AssetDetails
  * @property {string} name
  * @property {number} size
  */
 
 /**
- * @typedef {Object} EntrypointDetails
+ * @typedef {object} EntrypointDetails
  * @property {string} name
  * @property {number} size
  * @property {string[]} files
@@ -32,6 +33,12 @@ const NoAsyncChunksWarning = require("./NoAsyncChunksWarning");
 
 const isOverSizeLimitSet = new WeakSet();
 
+/**
+ * @param {Asset["name"]} name the name
+ * @param {Asset["source"]} source the source
+ * @param {Asset["info"]} info the info
+ * @returns {boolean} result
+ */
 const excludeSourceMap = (name, source, info) => !info.development;
 
 module.exports = class SizeLimitsPlugin {
@@ -95,7 +102,7 @@ module.exports = class SizeLimitsPlugin {
 				}
 
 				const size = info.size || source.size();
-				if (size > assetSizeLimit) {
+				if (size > /** @type {number} */ (assetSizeLimit)) {
 					assetsOverSizeLimit.push({
 						name,
 						size
@@ -104,6 +111,10 @@ module.exports = class SizeLimitsPlugin {
 				}
 			}
 
+			/**
+			 * @param {Asset["name"]} name the name
+			 * @returns {boolean | undefined} result
+			 */
 			const fileFilter = name => {
 				const asset = compilation.getAsset(name);
 				return asset && assetFilter(asset.name, asset.source, asset.info);
@@ -114,10 +125,10 @@ 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,
+						name,
+						size,
 						files: entry.getFiles().filter(fileFilter)
 					});
 					isOverSizeLimitSet.add(entry);
@@ -131,14 +142,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 {
@@ -23,11 +24,12 @@ class ChunkPrefetchFunctionRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	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 {
@@ -33,6 +35,7 @@ class ChunkPrefetchPreloadPlugin {
 						if (startupChildChunks) {
 							set.add(RuntimeGlobals.prefetchChunk);
 							set.add(RuntimeGlobals.onChunksLoaded);
+							set.add(RuntimeGlobals.exports);
 							compilation.addRuntimeModule(
 								chunk,
 								new ChunkPrefetchStartupRuntimeModule(startupChildChunks)
@@ -43,7 +46,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);