webpack 5.93.0 → 5.95.0

package/lib/stats/DefaultStatsFactoryPlugin.js

@@ -26,6 +26,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Chunk").ChunkId} ChunkId */
 /** @typedef {import("../ChunkGroup")} ChunkGroup */
 /** @typedef {import("../ChunkGroup").OriginRecord} OriginRecord */
 /** @typedef {import("../Compilation")} Compilation */
@@ -33,20 +34,28 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 /** @typedef {import("../Compilation").AssetInfo} AssetInfo */
 /** @typedef {import("../Compilation").NormalizedStatsOptions} NormalizedStatsOptions */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../ChunkGraph").ModuleId} ModuleId */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
 /** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("../ModuleProfile")} ModuleProfile */
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../WebpackError")} WebpackError */
-/** @template T @typedef {import("../util/comparators").Comparator<T>} Comparator<T> */
+/** @typedef {import("../TemplatedPathPlugin").TemplatePath} TemplatePath */
+/**
+ * @template T
+ * @typedef {import("../util/comparators").Comparator<T>} Comparator<T>
+ */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-/** @typedef {import("../util/smartGrouping").GroupConfig<any, object>} GroupConfig */
+/**
+ * @template T, R
+ * @typedef {import("../util/smartGrouping").GroupConfig<T, R>} GroupConfig
+ */
 /** @typedef {import("./StatsFactory")} StatsFactory */
 /** @typedef {import("./StatsFactory").StatsFactoryContext} StatsFactoryContext */
-
-/** @typedef {KnownStatsCompilation & Record<string, any>} StatsCompilation */
+/** @typedef {Record<string, any> & KnownStatsCompilation} StatsCompilation */
 /**
  * @typedef {object} KnownStatsCompilation
  * @property {any=} env
@@ -74,7 +83,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {Record<string, StatsLogging>=} logging
  */
 
-/** @typedef {KnownStatsLogging & Record<string, any>} StatsLogging */
+/** @typedef {Record<string, any> & KnownStatsLogging} StatsLogging */
 /**
  * @typedef {object} KnownStatsLogging
  * @property {StatsLoggingEntry[]} entries
@@ -82,18 +91,18 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {boolean} debug
  */
 
-/** @typedef {KnownStatsLoggingEntry & Record<string, any>} StatsLoggingEntry */
+/** @typedef {Record<string, any> & KnownStatsLoggingEntry} StatsLoggingEntry */
 /**
  * @typedef {object} KnownStatsLoggingEntry
  * @property {string} type
- * @property {string} message
+ * @property {string=} message
  * @property {string[]=} trace
  * @property {StatsLoggingEntry[]=} children
  * @property {any[]=} args
  * @property {number=} time
  */
 
-/** @typedef {KnownStatsAsset & Record<string, any>} StatsAsset */
+/** @typedef {Record<string, any> & KnownStatsAsset} StatsAsset */
 /**
  * @typedef {object} KnownStatsAsset
  * @property {string} type
@@ -114,7 +123,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {boolean=} isOverSizeLimit
  */
 
-/** @typedef {KnownStatsChunkGroup & Record<string, any>} StatsChunkGroup */
+/** @typedef {Record<string, any> & KnownStatsChunkGroup} StatsChunkGroup */
 /**
  * @typedef {object} KnownStatsChunkGroup
  * @property {string=} name
@@ -130,21 +139,21 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {boolean=} isOverSizeLimit
  */
 
-/** @typedef {KnownStatsModule & Record<string, any>} StatsModule */
+/** @typedef {Record<string, any> & KnownStatsModule} StatsModule */
 /**
  * @typedef {object} KnownStatsModule
  * @property {string=} type
  * @property {string=} moduleType
- * @property {string=} layer
+ * @property {(string | null)=} layer
  * @property {string=} identifier
  * @property {string=} name
- * @property {string=} nameForCondition
+ * @property {(string | null)=} nameForCondition
  * @property {number=} index
  * @property {number=} preOrderIndex
  * @property {number=} index2
  * @property {number=} postOrderIndex
  * @property {number=} size
- * @property {{[x: string]: number}=} sizes
+ * @property {{ [x: string]: number }=} sizes
  * @property {boolean=} cacheable
  * @property {boolean=} built
  * @property {boolean=} codeGenerated
@@ -152,29 +161,29 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {boolean=} cached
  * @property {boolean=} optional
  * @property {boolean=} orphan
- * @property {string|number=} id
- * @property {string|number=} issuerId
- * @property {(string|number)[]=} chunks
- * @property {(string|number)[]=} assets
+ * @property {string | number=} id
+ * @property {string | number | null=} issuerId
+ * @property {(string | number)[]=} chunks
+ * @property {(string | number)[]=} assets
  * @property {boolean=} dependent
- * @property {string=} issuer
- * @property {string=} issuerName
+ * @property {(string | null)=} issuer
+ * @property {(string | null)=} issuerName
  * @property {StatsModuleIssuer[]=} issuerPath
  * @property {boolean=} failed
  * @property {number=} errors
  * @property {number=} warnings
  * @property {StatsProfile=} profile
  * @property {StatsModuleReason[]=} reasons
- * @property {(boolean | string[])=} usedExports
- * @property {string[]=} providedExports
+ * @property {(boolean | null | string[])=} usedExports
+ * @property {(string[] | null)=} providedExports
  * @property {string[]=} optimizationBailout
- * @property {number=} depth
+ * @property {(number | null)=} depth
  * @property {StatsModule[]=} modules
  * @property {number=} filteredModules
  * @property {ReturnType<Source["source"]>=} source
  */
 
-/** @typedef {KnownStatsProfile & Record<string, any>} StatsProfile */
+/** @typedef {Record<string, any> & KnownStatsProfile} StatsProfile */
 /**
  * @typedef {object} KnownStatsProfile
  * @property {number} total
@@ -189,33 +198,33 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {number} dependencies
  */
 
-/** @typedef {KnownStatsModuleIssuer & Record<string, any>} StatsModuleIssuer */
+/** @typedef {Record<string, any> & KnownStatsModuleIssuer} StatsModuleIssuer */
 /**
  * @typedef {object} KnownStatsModuleIssuer
- * @property {string=} identifier
- * @property {string=} name
+ * @property {string} identifier
+ * @property {string} name
  * @property {(string|number)=} id
- * @property {StatsProfile=} profile
+ * @property {StatsProfile} profile
  */
 
-/** @typedef {KnownStatsModuleReason & Record<string, any>} StatsModuleReason */
+/** @typedef {Record<string, any> & KnownStatsModuleReason} StatsModuleReason */
 /**
  * @typedef {object} KnownStatsModuleReason
- * @property {string=} moduleIdentifier
- * @property {string=} module
- * @property {string=} moduleName
- * @property {string=} resolvedModuleIdentifier
- * @property {string=} resolvedModule
- * @property {string=} type
+ * @property {string | null} moduleIdentifier
+ * @property {string | null} module
+ * @property {string | null} moduleName
+ * @property {string | null} resolvedModuleIdentifier
+ * @property {string | null} resolvedModule
+ * @property {string | null} type
  * @property {boolean} active
- * @property {string=} explanation
- * @property {string=} userRequest
- * @property {string=} loc
- * @property {(string|number)=} moduleId
- * @property {(string|number)=} resolvedModuleId
+ * @property {string | null} explanation
+ * @property {string | null} userRequest
+ * @property {(string | null)=} loc
+ * @property {(string | number | null)=} moduleId
+ * @property {(string | number | null)=} resolvedModuleId
  */
 
-/** @typedef {KnownStatsChunk & Record<string, any>} StatsChunk */
+/** @typedef {Record<string, any> & KnownStatsChunk} StatsChunk */
 /**
  * @typedef {object} KnownStatsChunk
  * @property {boolean} rendered
@@ -224,14 +233,14 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {boolean} recorded
  * @property {string=} reason
  * @property {number} size
- * @property {Record<string, number>=} sizes
- * @property {string[]=} names
- * @property {string[]=} idHints
+ * @property {Record<string, number>} sizes
+ * @property {string[]} names
+ * @property {string[]} idHints
  * @property {string[]=} runtime
- * @property {string[]=} files
- * @property {string[]=} auxiliaryFiles
+ * @property {string[]} files
+ * @property {string[]} auxiliaryFiles
  * @property {string} hash
- * @property {Record<string, (string|number)[]>=} childrenByOrder
+ * @property {Record<string, (string|number)[]>} childrenByOrder
  * @property {(string|number)=} id
  * @property {(string|number)[]=} siblings
  * @property {(string|number)[]=} parents
@@ -241,18 +250,18 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {StatsChunkOrigin[]=} origins
  */
 
-/** @typedef {KnownStatsChunkOrigin & Record<string, any>} StatsChunkOrigin */
+/** @typedef {Record<string, any> & KnownStatsChunkOrigin} StatsChunkOrigin */
 /**
  * @typedef {object} KnownStatsChunkOrigin
- * @property {string=} module
- * @property {string=} moduleIdentifier
- * @property {string=} moduleName
- * @property {string=} loc
- * @property {string=} request
- * @property {(string|number)=} moduleId
+ * @property {string} module
+ * @property {string} moduleIdentifier
+ * @property {string} moduleName
+ * @property {string} loc
+ * @property {string} request
+ * @property {(string | number)=} moduleId
  */
 
-/** @typedef {KnownStatsModuleTraceItem & Record<string, any>} StatsModuleTraceItem */
+/** @typedef { Record<string, any> & KnownStatsModuleTraceItem} StatsModuleTraceItem */
 /**
  * @typedef {object} KnownStatsModuleTraceItem
  * @property {string=} originIdentifier
@@ -264,13 +273,13 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {(string|number)=} moduleId
  */
 
-/** @typedef {KnownStatsModuleTraceDependency & Record<string, any>} StatsModuleTraceDependency */
+/** @typedef {Record<string, any> & KnownStatsModuleTraceDependency} StatsModuleTraceDependency */
 /**
  * @typedef {object} KnownStatsModuleTraceDependency
  * @property {string=} loc
  */
 
-/** @typedef {KnownStatsError & Record<string, any>} StatsError */
+/** @typedef {Record<string, any> & KnownStatsError} StatsError */
 /**
  * @typedef {object} KnownStatsError
  * @property {string} message
@@ -281,14 +290,14 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {string=} moduleIdentifier
  * @property {string=} moduleName
  * @property {string=} loc
- * @property {string|number=} chunkId
+ * @property {ChunkId=} chunkId
  * @property {string|number=} moduleId
  * @property {StatsModuleTraceItem[]=} moduleTrace
  * @property {any=} details
  * @property {string=} stack
  */
 
-/** @typedef {Asset & { type: string, related: PreprocessedAsset[] }} PreprocessedAsset */
+/** @typedef {Asset & { type: string, related: PreprocessedAsset[] | undefined }} PreprocessedAsset */
 
 /**
  * @template T
@@ -341,15 +350,14 @@ const uniqueArray = (items, selector) => {
  * @param {Comparator<I>} comparator comparator function
  * @returns {I[]} array of values
  */
-const uniqueOrderedArray = (items, selector, comparator) => {
-	return uniqueArray(items, selector).sort(comparator);
-};
+const uniqueOrderedArray = (items, selector, comparator) =>
+	uniqueArray(items, selector).sort(comparator);
 
 /** @template T @template R @typedef {{ [P in keyof T]: R }} MappedValues<T, R> */
 
 /**
- * @template T
- * @template R
+ * @template {object} T
+ * @template {object} R
  * @param {T} obj object to be mapped
  * @param {function(T[keyof T], keyof T): R} fn mapping function
  * @returns {MappedValues<T, R>} mapped object
@@ -357,7 +365,10 @@ const uniqueOrderedArray = (items, selector, comparator) => {
 const mapObject = (obj, fn) => {
 	const newObj = Object.create(null);
 	for (const key of Object.keys(obj)) {
-		newObj[key] = fn(obj[key], /** @type {keyof T} */ (key));
+		newObj[key] = fn(
+			obj[/** @type {keyof T} */ (key)],
+			/** @type {keyof T} */ (key)
+		);
 	}
 	return newObj;
 };
@@ -405,10 +416,12 @@ const EXTRACT_ERROR = {
 	ids: (object, error, { compilation: { chunkGraph } }) => {
 		if (typeof error !== "string") {
 			if (error.chunk) {
-				object.chunkId = error.chunk.id;
+				object.chunkId = /** @type {ChunkId} */ (error.chunk.id);
 			}
 			if (error.module) {
-				object.moduleId = chunkGraph.getModuleId(error.module);
+				object.moduleId =
+					/** @type {ModuleId} */
+					(chunkGraph.getModuleId(error.module));
 			}
 		}
 	},
@@ -470,25 +483,21 @@ const SIMPLE_EXTRACTORS = {
 			}
 			if (!context.cachedGetErrors) {
 				const map = new WeakMap();
-				context.cachedGetErrors = compilation => {
-					return (
-						map.get(compilation) ||
-						(errors => (map.set(compilation, errors), errors))(
-							compilation.getErrors()
-						)
+				context.cachedGetErrors = compilation =>
+					map.get(compilation) ||
+					// eslint-disable-next-line no-sequences
+					(errors => (map.set(compilation, errors), errors))(
+						compilation.getErrors()
 					);
-				};
 			}
 			if (!context.cachedGetWarnings) {
 				const map = new WeakMap();
-				context.cachedGetWarnings = compilation => {
-					return (
-						map.get(compilation) ||
-						(warnings => (map.set(compilation, warnings), warnings))(
-							compilation.getWarnings()
-						)
+				context.cachedGetWarnings = compilation =>
+					map.get(compilation) ||
+					// eslint-disable-next-line no-sequences
+					(warnings => (map.set(compilation, warnings), warnings))(
+						compilation.getWarnings()
 					);
-				};
 			}
 			if (compilation.name) {
 				object.name = compilation.name;
@@ -504,9 +513,6 @@ const SIMPLE_EXTRACTORS = {
 				let acceptedTypes;
 				let collapsedGroups = false;
 				switch (logging) {
-					default:
-						acceptedTypes = new Set();
-						break;
 					case "error":
 						acceptedTypes = new Set([LogType.error]);
 						break;
@@ -549,6 +555,9 @@ const SIMPLE_EXTRACTORS = {
 						]);
 						collapsedGroups = true;
 						break;
+					default:
+						acceptedTypes = new Set();
+						break;
 				}
 				const cachedMakePathsRelative = makePathsRelative.bindContextCache(
 					options.context,
@@ -581,15 +590,16 @@ const SIMPLE_EXTRACTORS = {
 
 						if (type === LogType.groupEnd) {
 							groupStack.pop();
-							if (groupStack.length > 0) {
-								currentList = groupStack[groupStack.length - 1].children;
-							} else {
-								currentList = rootList;
-							}
+							currentList =
+								groupStack.length > 0
+									? /** @type {KnownStatsLoggingEntry[]} */ (
+											groupStack[groupStack.length - 1].children
+										)
+									: rootList;
 							if (depthInCollapsedGroup > 0) depthInCollapsedGroup--;
 							continue;
 						}
-						let message = undefined;
+						let message;
 						if (entry.type === LogType.time) {
 							message = `${entry.args[0]}: ${
 								entry.args[1] * 1000 + entry.args[2] / 1000000
@@ -636,7 +646,7 @@ const SIMPLE_EXTRACTORS = {
 			}
 		},
 		hash: (object, compilation) => {
-			object.hash = compilation.hash;
+			object.hash = /** @type {string} */ (compilation.hash);
 		},
 		version: object => {
 			object.version = require("../../package.json").version;
@@ -645,18 +655,23 @@ const SIMPLE_EXTRACTORS = {
 			object.env = _env;
 		},
 		timings: (object, compilation) => {
-			object.time = compilation.endTime - compilation.startTime;
+			object.time =
+				/** @type {number} */ (compilation.endTime) -
+				/** @type {number} */ (compilation.startTime);
 		},
 		builtAt: (object, compilation) => {
-			object.builtAt = compilation.endTime;
+			object.builtAt = /** @type {number} */ (compilation.endTime);
 		},
 		publicPath: (object, compilation) => {
 			object.publicPath = compilation.getPath(
-				compilation.outputOptions.publicPath
+				/** @type {TemplatePath} */
+				(compilation.outputOptions.publicPath)
 			);
 		},
 		outputPath: (object, compilation) => {
-			object.outputPath = compilation.outputOptions.path;
+			object.outputPath = /** @type {string} */ (
+				compilation.outputOptions.path
+			);
 		},
 		assets: (object, compilation, context, options, factory) => {
 			const { type } = context;
@@ -741,7 +756,10 @@ const SIMPLE_EXTRACTORS = {
 					compilationAuxiliaryFileToChunks
 				}
 			);
-			const limited = spaceLimited(groupedAssets, options.assetsSpace);
+			const limited = spaceLimited(
+				groupedAssets,
+				/** @type {number} */ (options.assetsSpace)
+			);
 			object.assets = limited.children;
 			object.filteredAssets = limited.filteredChildren;
 		},
@@ -834,7 +852,8 @@ const SIMPLE_EXTRACTORS = {
 			}
 			const [errors, filteredBySpace] = errorsSpaceLimit(
 				factorizedErrors,
-				options.errorsSpace
+				/** @type {number} */
+				(options.errorsSpace)
 			);
 			object.filteredErrorDetailsCount = filtered + filteredBySpace;
 			object.errors = errors;
@@ -867,7 +886,8 @@ const SIMPLE_EXTRACTORS = {
 			}
 			const [warnings, filteredBySpace] = errorsSpaceLimit(
 				rawWarnings,
-				options.warningsSpace
+				/** @type {number} */
+				(options.warningsSpace)
 			);
 			object.filteredWarningDetailsCount = filtered + filteredBySpace;
 			object.warnings = warnings;
@@ -881,18 +901,31 @@ const SIMPLE_EXTRACTORS = {
 		) => {
 			const { type, cachedGetWarnings } = context;
 			object.warningsCount = countWithChildren(compilation, (c, childType) => {
-				if (!warningsFilter && warningsFilter.length === 0)
+				if (
+					!warningsFilter &&
+					/** @type {((warning: StatsError, textValue: string) => boolean)[]} */
+					(warningsFilter).length === 0
+				)
 					return cachedGetWarnings(c);
 				return factory
 					.create(`${type}${childType}.warnings`, cachedGetWarnings(c), context)
-					.filter(warning => {
-						const warningString = Object.keys(warning)
-							.map(key => `${warning[key]}`)
-							.join("\n");
-						return !warningsFilter.some(filter =>
-							filter(warning, warningString)
-						);
-					});
+					.filter(
+						/**
+						 * @param {TODO} warning warning
+						 * @returns {boolean} result
+						 */
+						warning => {
+							const warningString = Object.keys(warning)
+								.map(
+									key =>
+										`${warning[/** @type {keyof KnownStatsError} */ (key)]}`
+								)
+								.join("\n");
+							return !warningsFilter.some(filter =>
+								filter(warning, warningString)
+							);
+						}
+					);
 			});
 		},
 		children: (object, compilation, context, options, factory) => {
@@ -960,11 +993,12 @@ const SIMPLE_EXTRACTORS = {
 			const { type } = context;
 			object.related = factory.create(
 				`${type.slice(0, -8)}.related`,
-				asset.related,
+				asset.related || [],
 				context
 			);
 			object.filteredRelated = asset.related
-				? asset.related.length - object.related.length
+				? asset.related.length -
+					/** @type {StatsAsset[]} */ (object.related).length
 				: undefined;
 		},
 		ids: (
@@ -975,10 +1009,14 @@ const SIMPLE_EXTRACTORS = {
 			const chunks = compilationFileToChunks.get(asset.name) || [];
 			const auxiliaryChunks =
 				compilationAuxiliaryFileToChunks.get(asset.name) || [];
-			object.chunks = uniqueOrderedArray(chunks, c => c.ids, compareIds);
+			object.chunks = uniqueOrderedArray(
+				chunks,
+				c => /** @type {ChunkId[]} */ (c.ids),
+				compareIds
+			);
 			object.auxiliaryChunks = uniqueOrderedArray(
 				auxiliaryChunks,
-				c => c.ids,
+				c => /** @type {ChunkId[]} */ (c.ids),
 				compareIds
 			);
 		},
@@ -1004,7 +1042,7 @@ const SIMPLE_EXTRACTORS = {
 				const asset = compilation.getAsset(name);
 				return {
 					name,
-					size: asset ? asset.info.size : -1
+					size: /** @type {number} */ (asset ? asset.info.size : -1)
 				};
 			};
 			/** @type {(total: number, asset: { size: number }) => number} */
@@ -1020,7 +1058,9 @@ const SIMPLE_EXTRACTORS = {
 			/** @type {KnownStatsChunkGroup} */
 			const statsChunkGroup = {
 				name,
-				chunks: ids ? chunkGroup.chunks.map(c => c.id) : undefined,
+				chunks: ids
+					? /** @type {ChunkId[]} */ (chunkGroup.chunks.map(c => c.id))
+					: undefined,
 				assets: assets.length <= chunkGroupMaxAssets ? assets : undefined,
 				filteredAssets:
 					assets.length <= chunkGroupMaxAssets ? 0 : assets.length,
@@ -1049,7 +1089,10 @@ const SIMPLE_EXTRACTORS = {
 								/** @type {KnownStatsChunkGroup} */
 								const childStatsChunkGroup = {
 									name: group.name,
-									chunks: ids ? group.chunks.map(c => c.id) : undefined,
+									chunks: ids
+										? /** @type {ChunkId[]} */
+											(group.chunks.map(c => c.id))
+										: undefined,
 									assets:
 										assets.length <= chunkGroupMaxAssets ? assets : undefined,
 									filteredAssets:
@@ -1093,7 +1136,8 @@ const SIMPLE_EXTRACTORS = {
 	},
 	module: {
 		_: (object, module, context, options, factory) => {
-			const { compilation, type } = context;
+			const { type } = context;
+			const compilation = /** @type {Compilation} */ (context.compilation);
 			const built = compilation.builtModules.has(module);
 			const codeGenerated = compilation.codeGeneratedModules.has(module);
 			const buildTimeExecuted =
@@ -1127,7 +1171,8 @@ const SIMPLE_EXTRACTORS = {
 	},
 	module$visible: {
 		_: (object, module, context, { requestShortener }, factory) => {
-			const { compilation, type, rootModules } = context;
+			const { type, rootModules } = context;
+			const compilation = /** @type {Compilation} */ (context.compilation);
 			const { moduleGraph } = compilation;
 			/** @type {Module[]} */
 			const path = [];
@@ -1154,11 +1199,15 @@ const SIMPLE_EXTRACTORS = {
 				identifier: module.identifier(),
 				name: module.readableIdentifier(requestShortener),
 				nameForCondition: module.nameForCondition(),
-				index: moduleGraph.getPreOrderIndex(module),
-				preOrderIndex: moduleGraph.getPreOrderIndex(module),
-				index2: moduleGraph.getPostOrderIndex(module),
-				postOrderIndex: moduleGraph.getPostOrderIndex(module),
-				cacheable: module.buildInfo.cacheable,
+				index: /** @type {number} */ (moduleGraph.getPreOrderIndex(module)),
+				preOrderIndex: /** @type {number} */ (
+					moduleGraph.getPreOrderIndex(module)
+				),
+				index2: /** @type {number} */ (moduleGraph.getPostOrderIndex(module)),
+				postOrderIndex: /** @type {number} */ (
+					moduleGraph.getPostOrderIndex(module)
+				),
+				cacheable: /** @type {BuildInfo} */ (module.buildInfo).cacheable,
 				optional: module.isOptional(moduleGraph),
 				orphan:
 					!type.endsWith("module.modules[].module$visible") &&
@@ -1183,17 +1232,24 @@ const SIMPLE_EXTRACTORS = {
 			}
 		},
 		ids: (object, module, { compilation: { chunkGraph, moduleGraph } }) => {
-			object.id = chunkGraph.getModuleId(module);
+			object.id = /** @type {ModuleId} */ (chunkGraph.getModuleId(module));
 			const issuer = moduleGraph.getIssuer(module);
 			object.issuerId = issuer && chunkGraph.getModuleId(issuer);
-			object.chunks = Array.from(
-				chunkGraph.getOrderedModuleChunksIterable(module, compareChunksById),
-				chunk => chunk.id
-			);
+			object.chunks =
+				/** @type {ChunkId[]} */
+				(
+					Array.from(
+						chunkGraph.getOrderedModuleChunksIterable(
+							module,
+							compareChunksById
+						),
+						chunk => chunk.id
+					)
+				);
 		},
 		moduleAssets: (object, module) => {
-			object.assets = module.buildInfo.assets
-				? Object.keys(module.buildInfo.assets)
+			object.assets = /** @type {BuildInfo} */ (module.buildInfo).assets
+				? Object.keys(/** @type {BuildInfo} */ (module.buildInfo).assets)
 				: [];
 		},
 		reasons: (object, module, context, options, factory) => {
@@ -1206,7 +1262,11 @@ const SIMPLE_EXTRACTORS = {
 				Array.from(moduleGraph.getIncomingConnections(module)),
 				context
 			);
-			const limited = spaceLimited(groupsReasons, options.reasonsSpace);
+			const limited = spaceLimited(
+				groupsReasons,
+				/** @type {number} */
+				(options.reasonsSpace)
+			);
 			object.reasons = limited.children;
 			object.filteredReasons = limited.filteredChildren;
 		},
@@ -1299,10 +1359,11 @@ const SIMPLE_EXTRACTORS = {
 	},
 	moduleIssuer: {
 		_: (object, module, context, { requestShortener }, factory) => {
-			const { compilation, type } = context;
+			const { type } = context;
+			const compilation = /** @type {Compilation} */ (context.compilation);
 			const { moduleGraph } = compilation;
 			const profile = moduleGraph.getProfile(module);
-			/** @type {KnownStatsModuleIssuer} */
+			/** @type {Partial<KnownStatsModuleIssuer>} */
 			const statsModuleIssuer = {
 				identifier: module.identifier(),
 				name: module.readableIdentifier(requestShortener)
@@ -1313,7 +1374,7 @@ const SIMPLE_EXTRACTORS = {
 			}
 		},
 		ids: (object, module, { compilation: { chunkGraph } }) => {
-			object.id = chunkGraph.getModuleId(module);
+			object.id = /** @type {ModuleId} */ (chunkGraph.getModuleId(module));
 		}
 	},
 	moduleReason: {
@@ -1383,13 +1444,13 @@ const SIMPLE_EXTRACTORS = {
 							: Array.from(chunk.runtime.sort(), makePathsRelative),
 				files: Array.from(chunk.files),
 				auxiliaryFiles: Array.from(chunk.auxiliaryFiles).sort(compareIds),
-				hash: chunk.renderedHash,
+				hash: /** @type {string} */ (chunk.renderedHash),
 				childrenByOrder: childIdByOrder
 			};
 			Object.assign(object, statsChunk);
 		},
 		ids: (object, chunk) => {
-			object.id = chunk.id;
+			object.id = /** @type {ChunkId} */ (chunk.id);
 		},
 		chunkRelations: (object, chunk, { compilation: { chunkGraph } }) => {
 			/** @type {Set<string|number>} */
@@ -1402,16 +1463,17 @@ const SIMPLE_EXTRACTORS = {
 			for (const chunkGroup of chunk.groupsIterable) {
 				for (const parentGroup of chunkGroup.parentsIterable) {
 					for (const chunk of parentGroup.chunks) {
-						parents.add(chunk.id);
+						parents.add(/** @type {ChunkId} */ (chunk.id));
 					}
 				}
 				for (const childGroup of chunkGroup.childrenIterable) {
 					for (const chunk of childGroup.chunks) {
-						children.add(chunk.id);
+						children.add(/** @type {ChunkId} */ (chunk.id));
 					}
 				}
 				for (const sibling of chunkGroup.chunks) {
-					if (sibling !== chunk) siblings.add(sibling.id);
+					if (sibling !== chunk)
+						siblings.add(/** @type {ChunkId} */ (sibling.id));
 				}
 			}
 			object.siblings = Array.from(siblings).sort(compareIds);
@@ -1473,7 +1535,7 @@ const SIMPLE_EXTRACTORS = {
 		},
 		ids: (object, origin, { compilation: { chunkGraph } }) => {
 			object.moduleId = origin.module
-				? chunkGraph.getModuleId(origin.module)
+				? /** @type {ModuleId} */ (chunkGraph.getModuleId(origin.module))
 				: undefined;
 		}
 	},
@@ -1501,8 +1563,12 @@ const SIMPLE_EXTRACTORS = {
 			);
 		},
 		ids: (object, { origin, module }, { compilation: { chunkGraph } }) => {
-			object.originId = chunkGraph.getModuleId(origin);
-			object.moduleId = chunkGraph.getModuleId(module);
+			object.originId =
+				/** @type {ModuleId} */
+				(chunkGraph.getModuleId(origin));
+			object.moduleId =
+				/** @type {ModuleId} */
+				(chunkGraph.getModuleId(module));
 		}
 	},
 	moduleTraceDependency: {
@@ -1526,13 +1592,13 @@ const FILTER = {
 	}
 };
 
-/** @type {Record<string, Record<string, (thing: object, context: StatsFactoryContext, options: NormalizedStatsOptions) => boolean | undefined>>} */
+/** @type {Record<string, Record<string, (thing: KnownStatsError, context: StatsFactoryContext, options: NormalizedStatsOptions) => boolean | undefined>>} */
 const FILTER_RESULTS = {
 	"compilation.warnings": {
 		warningsFilter: util.deprecate(
 			(warning, context, { warningsFilter }) => {
 				const warningString = Object.keys(warning)
-					.map(key => `${warning[key]}`)
+					.map(key => `${warning[/** @type {keyof KnownStatsError} */ (key)]}`)
 					.join("\n");
 				return !warningsFilter.some(filter => filter(warning, warningString));
 			},
@@ -1549,7 +1615,7 @@ const MODULES_SORTER = {
 			compareSelect(
 				/**
 				 * @param {Module} m module
-				 * @returns {number} depth
+				 * @returns {number | null} depth
 				 */
 				m => moduleGraph.getDepth(m),
 				compareNumbers
@@ -1557,7 +1623,7 @@ const MODULES_SORTER = {
 			compareSelect(
 				/**
 				 * @param {Module} m module
-				 * @returns {number} index
+				 * @returns {number | null} index
 				 */
 				m => moduleGraph.getPreOrderIndex(m),
 				compareNumbers
@@ -1626,17 +1692,31 @@ const SORTERS = {
 	}
 };
 
-const getItemSize = item => {
+/**
+ * @template T
+ * @typedef {T & { children: Children<T>[] | undefined, filteredChildren?: number }} Children
+ */
+
+/**
+ * @template T
+ * @param {Children<T>} item item
+ * @returns {number} item size
+ */
+const getItemSize = item =>
 	// Each item takes 1 line
 	// + the size of the children
 	// + 1 extra line when it has children and filteredChildren
-	return !item.children
+	!item.children
 		? 1
 		: item.filteredChildren
 			? 2 + getTotalSize(item.children)
 			: 1 + getTotalSize(item.children);
-};
 
+/**
+ * @template T
+ * @param {Children<T>[]} children children
+ * @returns {number} total size
+ */
 const getTotalSize = children => {
 	let size = 0;
 	for (const child of children) {
@@ -1645,6 +1725,11 @@ const getTotalSize = children => {
 	return size;
 };
 
+/**
+ * @template T
+ * @param {Children<T>[]} children children
+ * @returns {number} total items
+ */
 const getTotalItems = children => {
 	let count = 0;
 	for (const child of children) {
@@ -1658,6 +1743,11 @@ const getTotalItems = children => {
 	return count;
 };
 
+/**
+ * @template T
+ * @param {Children<T>[]} children children
+ * @returns {Children<T>[]} collapsed children
+ */
 const collapse = children => {
 	// After collapse each child must take exactly one line
 	const newChildren = [];
@@ -1677,24 +1767,33 @@ const collapse = children => {
 	return newChildren;
 };
 
+/**
+ * @template T
+ * @param {Children<T>[]} itemsAndGroups item and groups
+ * @param {number} max max
+ * @param {boolean=} filteredChildrenLineReserved filtered children line reserved
+ * @returns {Children<T>} result
+ */
 const spaceLimited = (
 	itemsAndGroups,
 	max,
 	filteredChildrenLineReserved = false
 ) => {
 	if (max < 1) {
-		return {
+		return /** @type {Children<T>} */ ({
 			children: undefined,
 			filteredChildren: getTotalItems(itemsAndGroups)
-		};
+		});
 	}
-	/** @type {any[] | undefined} */
-	let children = undefined;
+	/** @type {Children<T>[] | undefined} */
+	let children;
 	/** @type {number | undefined} */
-	let filteredChildren = undefined;
+	let filteredChildren;
 	// This are the groups, which take 1+ lines each
+	/** @type {Children<T>[] | undefined} */
 	const groups = [];
 	// The sizes of the groups are stored in groupSizes
+	/** @type {number[]} */
 	const groupSizes = [];
 	// This are the items, which take 1 line each
 	const items = [];
@@ -1757,7 +1856,7 @@ const spaceLimited = (
 						// So it should always end up being smaller
 						const headerSize = group.filteredChildren ? 2 : 1;
 						const limited = spaceLimited(
-							group.children,
+							/** @type {Children<T>} */ (group.children),
 							maxGroupSize -
 								// we should use ceil to always feet in max
 								Math.ceil(oversize / groups.length) -
@@ -1792,12 +1891,14 @@ const spaceLimited = (
 		}
 	}
 
-	return {
-		children,
-		filteredChildren
-	};
+	return /** @type {Children<T>} */ ({ children, filteredChildren });
 };
 
+/**
+ * @param {StatsError[]} errors errors
+ * @param {number} max max
+ * @returns {[StatsError[], number]} error space limit
+ */
 const errorsSpaceLimit = (errors, max) => {
 	let filtered = 0;
 	// Can not fit into limit
@@ -1853,18 +1954,30 @@ const errorsSpaceLimit = (errors, max) => {
 	return [result, filtered];
 };
 
+/**
+ * @template {{ size: number }} T
+ * @template {{ size: number }} R
+ * @param {(R | T)[]} children children
+ * @param {T[]} assets assets
+ * @returns {{ size: number }} asset size
+ */
 const assetGroup = (children, assets) => {
 	let size = 0;
 	for (const asset of children) {
 		size += asset.size;
 	}
-	return {
-		size
-	};
+	return { size };
 };
 
+/**
+ * @template {{ size: number, sizes: Record<string, number> }} T
+ * @param {Children<T>[]} children children
+ * @param {KnownStatsModule[]} modules modules
+ * @returns {{ size: number, sizes: Record<string, number>}} size and sizes
+ */
 const moduleGroup = (children, modules) => {
 	let size = 0;
+	/** @type {Record<string, number>} */
 	const sizes = {};
 	for (const module of children) {
 		size += module.size;
@@ -1878,6 +1991,12 @@ const moduleGroup = (children, modules) => {
 	};
 };
 
+/**
+ * @template {{ active: boolean }} T
+ * @param {Children<T>[]} children children
+ * @param {KnownStatsModuleReason[]} reasons reasons
+ * @returns {{ active: boolean }} reason group
+ */
 const reasonGroup = (children, reasons) => {
 	let active = false;
 	for (const reason of children) {
@@ -1891,35 +2010,36 @@ const reasonGroup = (children, reasons) => {
 const GROUP_EXTENSION_REGEXP = /(\.[^.]+?)(?:\?|(?: \+ \d+ modules?)?$)/;
 const GROUP_PATH_REGEXP = /(.+)[/\\][^/\\]+?(?:\?|(?: \+ \d+ modules?)?$)/;
 
-/** @type {Record<string, (groupConfigs: GroupConfig[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>} */
+/** @typedef {Record<string, (groupConfigs: GroupConfig<KnownStatsAsset, TODO>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>} AssetsGroupers */
+
+/** @type {AssetsGroupers} */
 const ASSETS_GROUPERS = {
 	_: (groupConfigs, context, options) => {
+		/**
+		 * @param {keyof KnownStatsAsset} name name
+		 * @param {boolean=} exclude need exclude?
+		 */
 		const groupByFlag = (name, exclude) => {
 			groupConfigs.push({
-				getKeys: asset => {
-					return asset[name] ? ["1"] : undefined;
-				},
-				getOptions: () => {
-					return {
-						groupChildren: !exclude,
-						force: exclude
-					};
-				},
-				createGroup: (key, children, assets) => {
-					return exclude
+				getKeys: asset => (asset[name] ? ["1"] : undefined),
+				getOptions: () => ({
+					groupChildren: !exclude,
+					force: exclude
+				}),
+				createGroup: (key, children, assets) =>
+					exclude
 						? {
 								type: "assets by status",
-								[name]: !!key,
+								[name]: Boolean(key),
 								filteredChildren: assets.length,
 								...assetGroup(children, assets)
 							}
 						: {
 								type: "assets by status",
-								[name]: !!key,
+								[name]: Boolean(key),
 								children,
 								...assetGroup(children, assets)
-							};
-				}
+							}
 			});
 		};
 		const {
@@ -1954,41 +2074,38 @@ const ASSETS_GROUPERS = {
 									: `*${extension}`
 							);
 						while (path.length > 0) {
-							keys.push(path.join("/") + "/");
+							keys.push(`${path.join("/")}/`);
 							path.pop();
 						}
-					} else {
-						if (extension) keys.push(`*${extension}`);
+					} else if (extension) {
+						keys.push(`*${extension}`);
 					}
 					return keys;
 				},
-				createGroup: (key, children, assets) => {
-					return {
-						type: groupAssetsByPath ? "assets by path" : "assets by extension",
-						name: key,
-						children,
-						...assetGroup(children, assets)
-					};
-				}
+				createGroup: (key, children, assets) => ({
+					type: groupAssetsByPath ? "assets by path" : "assets by extension",
+					name: key,
+					children,
+					...assetGroup(children, assets)
+				})
 			});
 		}
 	},
 	groupAssetsByInfo: (groupConfigs, context, options) => {
+		/**
+		 * @param {string} name name
+		 */
 		const groupByAssetInfoFlag = name => {
 			groupConfigs.push({
-				getKeys: asset => {
-					return asset.info && asset.info[name] ? ["1"] : undefined;
-				},
-				createGroup: (key, children, assets) => {
-					return {
-						type: "assets by info",
-						info: {
-							[name]: !!key
-						},
-						children,
-						...assetGroup(children, assets)
-					};
-				}
+				getKeys: asset => (asset.info && asset.info[name] ? ["1"] : undefined),
+				createGroup: (key, children, assets) => ({
+					type: "assets by info",
+					info: {
+						[name]: Boolean(key)
+					},
+					children,
+					...assetGroup(children, assets)
+				})
 			});
 		};
 		groupByAssetInfoFlag("immutable");
@@ -1996,19 +2113,18 @@ const ASSETS_GROUPERS = {
 		groupByAssetInfoFlag("hotModuleReplacement");
 	},
 	groupAssetsByChunk: (groupConfigs, context, options) => {
+		/**
+		 * @param {keyof KnownStatsAsset} name name
+		 */
 		const groupByNames = name => {
 			groupConfigs.push({
-				getKeys: asset => {
-					return asset[name];
-				},
-				createGroup: (key, children, assets) => {
-					return {
-						type: "assets by chunk",
-						[name]: [key],
-						children,
-						...assetGroup(children, assets)
-					};
-				}
+				getKeys: asset => /** @type {string[]} */ (asset[name]),
+				createGroup: (key, children, assets) => ({
+					type: "assets by chunk",
+					[name]: [key],
+					children,
+					...assetGroup(children, assets)
+				})
 			});
 		};
 		groupByNames("chunkNames");
@@ -2036,28 +2152,29 @@ const ASSETS_GROUPERS = {
 	}
 };
 
-/** @type {function("module" | "chunk" | "root-of-chunk" | "nested"): Record<string, (groupConfigs: GroupConfig[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>} */
+/** @typedef {Record<string, (groupConfigs: GroupConfig<KnownStatsModule, TODO>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>} ModulesGroupers */
+
+/** @type {function("module" | "chunk" | "root-of-chunk" | "nested"): ModulesGroupers} */
 const MODULES_GROUPERS = type => ({
 	_: (groupConfigs, context, options) => {
+		/**
+		 * @param {keyof KnownStatsModule} name name
+		 * @param {string} type type
+		 * @param {boolean=} exclude need exclude?
+		 */
 		const groupByFlag = (name, type, exclude) => {
 			groupConfigs.push({
-				getKeys: module => {
-					return module[name] ? ["1"] : undefined;
-				},
-				getOptions: () => {
-					return {
-						groupChildren: !exclude,
-						force: exclude
-					};
-				},
-				createGroup: (key, children, modules) => {
-					return {
-						type,
-						[name]: !!key,
-						...(exclude ? { filteredChildren: modules.length } : { children }),
-						...moduleGroup(children, modules)
-					};
-				}
+				getKeys: module => (module[name] ? ["1"] : undefined),
+				getOptions: () => ({
+					groupChildren: !exclude,
+					force: exclude
+				}),
+				createGroup: (key, children, modules) => ({
+					type,
+					[name]: Boolean(key),
+					...(exclude ? { filteredChildren: modules.length } : { children }),
+					...moduleGroup(children, modules)
+				})
 			});
 		};
 		const {
@@ -2120,24 +2237,22 @@ const MODULES_GROUPERS = type => ({
 		}
 		if (groupModulesByLayer) {
 			groupConfigs.push({
-				getKeys: module => {
-					return [module.layer];
-				},
-				createGroup: (key, children, modules) => {
-					return {
-						type: "modules by layer",
-						layer: key,
-						children,
-						...moduleGroup(children, modules)
-					};
-				}
+				getKeys: module => /** @type {string[]} */ ([module.layer]),
+				createGroup: (key, children, modules) => ({
+					type: "modules by layer",
+					layer: key,
+					children,
+					...moduleGroup(children, modules)
+				})
 			});
 		}
 		if (groupModulesByPath || groupModulesByExtension) {
 			groupConfigs.push({
 				getKeys: module => {
 					if (!module.name) return;
-					const resource = parseResource(module.name.split("!").pop()).path;
+					const resource = parseResource(
+						/** @type {string} */ (module.name.split("!").pop())
+					).path;
 					const dataUrl = /^data:[^,;]+/.exec(resource);
 					if (dataUrl) return [dataUrl[0]];
 					const extensionMatch =
@@ -2155,11 +2270,11 @@ const MODULES_GROUPERS = type => ({
 									: `*${extension}`
 							);
 						while (path.length > 0) {
-							keys.push(path.join("/") + "/");
+							keys.push(`${path.join("/")}/`);
 							path.pop();
 						}
-					} else {
-						if (extension) keys.push(`*${extension}`);
+					} else if (extension) {
+						keys.push(`*${extension}`);
 					}
 					return keys;
 				},
@@ -2201,7 +2316,24 @@ const MODULES_GROUPERS = type => ({
 	}
 });
 
-/** @type {Record<string, Record<string, (groupConfigs: GroupConfig[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>>} */
+/** @typedef {Record<string, (groupConfigs: import("../util/smartGrouping").GroupConfig<KnownStatsModuleReason, TODO>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>} ModuleReasonsGroupers */
+
+/** @type {ModuleReasonsGroupers} */
+const MODULE_REASONS_GROUPERS = {
+	groupReasonsByOrigin: groupConfigs => {
+		groupConfigs.push({
+			getKeys: reason => /** @type {string[]} */ ([reason.module]),
+			createGroup: (key, children, reasons) => ({
+				type: "from origin",
+				module: key,
+				children,
+				...reasonGroup(children, reasons)
+			})
+		});
+	}
+};
+
+/** @type {Record<string, AssetsGroupers | ModulesGroupers | ModuleReasonsGroupers>} */
 const RESULT_GROUPERS = {
 	"compilation.assets": ASSETS_GROUPERS,
 	"asset.related": ASSETS_GROUPERS,
@@ -2209,26 +2341,14 @@ const RESULT_GROUPERS = {
 	"chunk.modules": MODULES_GROUPERS("chunk"),
 	"chunk.rootModules": MODULES_GROUPERS("root-of-chunk"),
 	"module.modules": MODULES_GROUPERS("nested"),
-	"module.reasons": {
-		groupReasonsByOrigin: groupConfigs => {
-			groupConfigs.push({
-				getKeys: reason => {
-					return [reason.module];
-				},
-				createGroup: (key, children, reasons) => {
-					return {
-						type: "from origin",
-						module: key,
-						children,
-						...reasonGroup(children, reasons)
-					};
-				}
-			});
-		}
-	}
+	"module.reasons": MODULE_REASONS_GROUPERS
 };
 
 // remove a prefixed "!" that can be specified to reverse sort order
+/**
+ * @param {string} field a field name
+ * @returns {field} normalized field
+ */
 const normalizeFieldKey = field => {
 	if (field[0] === "!") {
 		return field.slice(1);
@@ -2237,6 +2357,10 @@ const normalizeFieldKey = field => {
 };
 
 // if a field is prefixed by a "!" reverse sort order
+/**
+ * @param {string} field a field name
+ * @returns {boolean} result
+ */
 const sortOrderRegular = field => {
 	if (field[0] === "!") {
 		return false;
@@ -2246,7 +2370,7 @@ const sortOrderRegular = field => {
 
 /**
  * @param {string} field field name
- * @returns {function(object, object): number} comparators
+ * @returns {function(object, object): 0 | 1 | -1} comparators
  */
 const sortByField = field => {
 	if (!field) {
@@ -2274,8 +2398,8 @@ const sortByField = field => {
 	return sortFn;
 };
 
+/** @type {Record<string, (comparators: Comparator<TODO>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>} */
 const ASSET_SORTERS = {
-	/** @type {(comparators: Function[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void} */
 	assetsSort: (comparators, context, { assetsSort }) => {
 		comparators.push(sortByField(assetsSort));
 	},
@@ -2284,7 +2408,7 @@ const ASSET_SORTERS = {
 	}
 };
 
-/** @type {Record<string, Record<string, (comparators: Function[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>>} */
+/** @type {Record<string, Record<string, (comparators: Comparator<TODO>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>>} */
 const RESULT_SORTERS = {
 	"compilation.chunks": {
 		chunksSort: (comparators, context, { chunksSort }) => {
@@ -2361,8 +2485,14 @@ const ITEM_NAMES = {
 };
 
 /**
- * @param {object[]} items items to be merged
- * @returns {object} an object
+ * @template T
+ * @typedef {{ name: T }} NamedObject
+ */
+
+/**
+ * @template {{ name: string }} T
+ * @param {T[]} items items to be merged
+ * @returns {NamedObject<T>} an object
  */
 const mergeToObject = items => {
 	const obj = Object.create(null);
@@ -2372,7 +2502,10 @@ const mergeToObject = items => {
 	return obj;
 };
 
-/** @type {Record<string, (items: object[]) => any>} */
+/**
+ * @template {{ name: string }} T
+ * @type {Record<string, (items: T[]) => NamedObject<T>>}
+ */
 const MERGER = {
 	"compilation.entrypoints": mergeToObject,
 	"compilation.namedChunkGroups": mergeToObject
@@ -2388,7 +2521,11 @@ class DefaultStatsFactoryPlugin {
 		compiler.hooks.compilation.tap("DefaultStatsFactoryPlugin", compilation => {
 			compilation.hooks.statsFactory.tap(
 				"DefaultStatsFactoryPlugin",
-				(stats, options, context) => {
+				/**
+				 * @param {StatsFactory} stats stats factory
+				 * @param {NormalizedStatsOptions} options stats options
+				 */
+				(stats, options) => {
 					iterateConfig(SIMPLE_EXTRACTORS, options, (hookFor, fn) => {
 						stats.hooks.extract
 							.for(hookFor)
@@ -2445,25 +2582,31 @@ class DefaultStatsFactoryPlugin {
 						if (Array.isArray(options.children)) {
 							stats.hooks.getItemFactory
 								.for("compilation.children[].compilation")
-								.tap("DefaultStatsFactoryPlugin", (comp, { _index: idx }) => {
-									if (idx < options.children.length) {
-										return compilation.createStatsFactory(
-											compilation.createStatsOptions(
-												options.children[idx],
-												context
-											)
-										);
+								.tap(
+									"DefaultStatsFactoryPlugin",
+									/**
+									 * @param {Compilation} comp compilation
+									 * @param {StatsFactoryContext} options options
+									 * @returns {StatsFactory | undefined} stats factory
+									 */
+									(comp, { _index: idx }) => {
+										const children =
+											/** @type {TODO} */
+											(options.children);
+										if (idx < children.length) {
+											return compilation.createStatsFactory(
+												compilation.createStatsOptions(children[idx])
+											);
+										}
 									}
-								});
+								);
 						} else if (options.children !== true) {
 							const childFactory = compilation.createStatsFactory(
-								compilation.createStatsOptions(options.children, context)
+								compilation.createStatsOptions(options.children)
 							);
 							stats.hooks.getItemFactory
 								.for("compilation.children[].compilation")
-								.tap("DefaultStatsFactoryPlugin", () => {
-									return childFactory;
-								});
+								.tap("DefaultStatsFactoryPlugin", () => childFactory);
 						}
 					}
 				}