webpack 5.97.1 → 5.104.1

package/lib/stats/DefaultStatsFactoryPlugin.js

@@ -14,51 +14,59 @@ const AggressiveSplittingPlugin = require("../optimize/AggressiveSplittingPlugin
 const SizeLimitsPlugin = require("../performance/SizeLimitsPlugin");
 const { countIterable } = require("../util/IterableHelpers");
 const {
-	compareLocations,
 	compareChunksById,
-	compareNumbers,
 	compareIds,
-	concatComparators,
+	compareLocations,
+	compareModulesByIdentifier,
+	compareNumbers,
 	compareSelect,
-	compareModulesByIdentifier
+	concatComparators
 } = require("../util/comparators");
 const { makePathsRelative, parseResource } = require("../util/identifier");
 
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").StatsValue} StatsValue */
+/** @typedef {import("./StatsFactory")} StatsFactory */
+/** @typedef {import("./StatsFactory").StatsFactoryContext} StatsFactoryContext */
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Chunk").ChunkId} ChunkId */
+/** @typedef {import("../Chunk").ChunkName} ChunkName */
+/** @typedef {import("../ChunkGraph").ModuleId} ModuleId */
 /** @typedef {import("../ChunkGroup")} ChunkGroup */
 /** @typedef {import("../ChunkGroup").OriginRecord} OriginRecord */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compilation").Asset} Asset */
 /** @typedef {import("../Compilation").AssetInfo} AssetInfo */
+/** @typedef {import("../Compilation").ExcludeModulesType} ExcludeModulesType */
+/** @typedef {import("../Compilation").KnownNormalizedStatsOptions} KnownNormalizedStatsOptions */
 /** @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").NameForCondition} NameForCondition */
 /** @typedef {import("../Module").BuildInfo} BuildInfo */
 /** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("../ModuleProfile")} ModuleProfile */
-/** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../WebpackError")} WebpackError */
-/** @typedef {import("../TemplatedPathPlugin").TemplatePath} TemplatePath */
+/** @typedef {import("../serialization/AggregateErrorSerializer").AggregateError} AggregateError */
+/** @typedef {import("../serialization/ErrorObjectSerializer").ErrorWithCause} ErrorWithCause */
+/** @typedef {import("../ExportsInfo").ExportInfoName} ExportInfoName */
+
 /**
  * @template T
  * @typedef {import("../util/comparators").Comparator<T>} Comparator<T>
  */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
 /**
- * @template T, R
- * @typedef {import("../util/smartGrouping").GroupConfig<T, R>} GroupConfig
+ * @template I, G
+ * @typedef {import("../util/smartGrouping").GroupConfig<I, G>} GroupConfig
  */
-/** @typedef {import("./StatsFactory")} StatsFactory */
-/** @typedef {import("./StatsFactory").StatsFactoryContext} StatsFactoryContext */
-/** @typedef {Record<string, EXPECTED_ANY> & KnownStatsCompilation} StatsCompilation */
+
+/** @typedef {KnownStatsCompilation & Record<string, EXPECTED_ANY>} StatsCompilation */
 /**
  * @typedef {object} KnownStatsCompilation
- * @property {any=} env
+ * @property {EXPECTED_ANY=} env
  * @property {string=} name
  * @property {string=} hash
  * @property {string=} version
@@ -81,9 +89,11 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {number=} warningsCount
  * @property {StatsCompilation[]=} children
  * @property {Record<string, StatsLogging>=} logging
+ * @property {number=} filteredWarningDetailsCount
+ * @property {number=} filteredErrorDetailsCount
  */
 
-/** @typedef {Record<string, EXPECTED_ANY> & KnownStatsLogging} StatsLogging */
+/** @typedef {KnownStatsLogging & Record<string, EXPECTED_ANY>} StatsLogging */
 /**
  * @typedef {object} KnownStatsLogging
  * @property {StatsLoggingEntry[]} entries
@@ -91,18 +101,19 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {boolean} debug
  */
 
-/** @typedef {Record<string, EXPECTED_ANY> & KnownStatsLoggingEntry} StatsLoggingEntry */
+/** @typedef {KnownStatsLoggingEntry & Record<string, EXPECTED_ANY>} StatsLoggingEntry */
 /**
  * @typedef {object} KnownStatsLoggingEntry
  * @property {string} type
  * @property {string=} message
  * @property {string[]=} trace
  * @property {StatsLoggingEntry[]=} children
- * @property {any[]=} args
+ * @property {EXPECTED_ANY[]=} args
  * @property {number=} time
  */
 
-/** @typedef {Record<string, EXPECTED_ANY> & KnownStatsAsset} StatsAsset */
+/** @typedef {KnownStatsAsset & Record<string, EXPECTED_ANY>} StatsAsset */
+/** @typedef {string[]} ChunkIdHints */
 /**
  * @typedef {object} KnownStatsAsset
  * @property {string} type
@@ -113,33 +124,34 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {boolean} comparedForEmit
  * @property {boolean} cached
  * @property {StatsAsset[]=} related
- * @property {(string|number)[]=} chunkNames
- * @property {(string|number)[]=} chunkIdHints
- * @property {(string|number)[]=} chunks
- * @property {(string|number)[]=} auxiliaryChunkNames
- * @property {(string|number)[]=} auxiliaryChunks
- * @property {(string|number)[]=} auxiliaryChunkIdHints
+ * @property {ChunkId[]=} chunks
+ * @property {ChunkName[]=} chunkNames
+ * @property {ChunkIdHints=} chunkIdHints
+ * @property {ChunkId[]=} auxiliaryChunks
+ * @property {ChunkName[]=} auxiliaryChunkNames
+ * @property {ChunkIdHints=} auxiliaryChunkIdHints
  * @property {number=} filteredRelated
  * @property {boolean=} isOverSizeLimit
  */
 
-/** @typedef {Record<string, EXPECTED_ANY> & KnownStatsChunkGroup} StatsChunkGroup */
+/** @typedef {KnownStatsChunkGroup & Record<string, EXPECTED_ANY>} StatsChunkGroup */
 /**
  * @typedef {object} KnownStatsChunkGroup
- * @property {(string | null)=} name
- * @property {(string | number)[]=} chunks
+ * @property {ChunkName=} name
+ * @property {ChunkId[]=} chunks
  * @property {({ name: string, size?: number })[]=} assets
  * @property {number=} filteredAssets
  * @property {number=} assetsSize
  * @property {({ name: string, size?: number })[]=} auxiliaryAssets
  * @property {number=} filteredAuxiliaryAssets
  * @property {number=} auxiliaryAssetsSize
- * @property {{ [x: string]: StatsChunkGroup[] }=} children
- * @property {{ [x: string]: string[] }=} childAssets
+ * @property {Record<string, StatsChunkGroup[]>=} children
+ * @property {Record<string, string[]>=} childAssets
  * @property {boolean=} isOverSizeLimit
  */
 
-/** @typedef {Record<string, EXPECTED_ANY> & KnownStatsModule} StatsModule */
+/** @typedef {Module[]} ModuleIssuerPath */
+/** @typedef {KnownStatsModule & Record<string, EXPECTED_ANY>} StatsModule */
 /**
  * @typedef {object} KnownStatsModule
  * @property {string=} type
@@ -147,13 +159,13 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {(string | null)=} layer
  * @property {string=} identifier
  * @property {string=} name
- * @property {(string | null)=} nameForCondition
+ * @property {NameForCondition | null=} nameForCondition
  * @property {number=} index
  * @property {number=} preOrderIndex
  * @property {number=} index2
  * @property {number=} postOrderIndex
  * @property {number=} size
- * @property {{ [x: string]: number }=} sizes
+ * @property {Record<string, number>=} sizes
  * @property {boolean=} cacheable
  * @property {boolean=} built
  * @property {boolean=} codeGenerated
@@ -161,21 +173,21 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {boolean=} cached
  * @property {boolean=} optional
  * @property {boolean=} orphan
- * @property {string | number=} id
- * @property {string | number | null=} issuerId
- * @property {(string | number)[]=} chunks
- * @property {(string | number)[]=} assets
+ * @property {ModuleId=} id
+ * @property {ModuleId | null=} issuerId
+ * @property {ChunkId[]=} chunks
+ * @property {string[]=} assets
  * @property {boolean=} dependent
  * @property {(string | null)=} issuer
  * @property {(string | null)=} issuerName
- * @property {StatsModuleIssuer[]=} issuerPath
+ * @property {StatsModuleIssuer[] | null=} issuerPath
  * @property {boolean=} failed
  * @property {number=} errors
  * @property {number=} warnings
  * @property {StatsProfile=} profile
  * @property {StatsModuleReason[]=} reasons
- * @property {(boolean | null | string[])=} usedExports
- * @property {(string[] | null)=} providedExports
+ * @property {boolean | null | ExportInfoName[]=} usedExports
+ * @property {ExportInfoName[] | null=} providedExports
  * @property {string[]=} optimizationBailout
  * @property {(number | null)=} depth
  * @property {StatsModule[]=} modules
@@ -183,7 +195,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {ReturnType<Source["source"]>=} source
  */
 
-/** @typedef {Record<string, EXPECTED_ANY> & KnownStatsProfile} StatsProfile */
+/** @typedef {KnownStatsProfile & Record<string, EXPECTED_ANY>} StatsProfile */
 /**
  * @typedef {object} KnownStatsProfile
  * @property {number} total
@@ -198,16 +210,16 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {number} dependencies
  */
 
-/** @typedef {Record<string, EXPECTED_ANY> & KnownStatsModuleIssuer} StatsModuleIssuer */
+/** @typedef {KnownStatsModuleIssuer & Record<string, EXPECTED_ANY>} StatsModuleIssuer */
 /**
  * @typedef {object} KnownStatsModuleIssuer
  * @property {string} identifier
  * @property {string} name
- * @property {(string|number)=} id
+ * @property {ModuleId=} id
  * @property {StatsProfile} profile
  */
 
-/** @typedef {Record<string, EXPECTED_ANY> & KnownStatsModuleReason} StatsModuleReason */
+/** @typedef {KnownStatsModuleReason & Record<string, EXPECTED_ANY>} StatsModuleReason */
 /**
  * @typedef {object} KnownStatsModuleReason
  * @property {string | null} moduleIdentifier
@@ -220,11 +232,11 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {string | null} explanation
  * @property {string | null} userRequest
  * @property {(string | null)=} loc
- * @property {(string | number | null)=} moduleId
- * @property {(string | number | null)=} resolvedModuleId
+ * @property {ModuleId | null=} moduleId
+ * @property {ModuleId | null=} resolvedModuleId
  */
 
-/** @typedef {Record<string, EXPECTED_ANY> & KnownStatsChunk} StatsChunk */
+/** @typedef {KnownStatsChunk & Record<string, EXPECTED_ANY>} StatsChunk */
 /**
  * @typedef {object} KnownStatsChunk
  * @property {boolean} rendered
@@ -240,17 +252,17 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {string[]} files
  * @property {string[]} auxiliaryFiles
  * @property {string} hash
- * @property {Record<string, (string|number)[]>} childrenByOrder
- * @property {(string|number)=} id
- * @property {(string|number)[]=} siblings
- * @property {(string|number)[]=} parents
- * @property {(string|number)[]=} children
+ * @property {Record<string, ChunkId[]>} childrenByOrder
+ * @property {ChunkId=} id
+ * @property {ChunkId[]=} siblings
+ * @property {ChunkId[]=} parents
+ * @property {ChunkId[]=} children
  * @property {StatsModule[]=} modules
  * @property {number=} filteredModules
  * @property {StatsChunkOrigin[]=} origins
  */
 
-/** @typedef {Record<string, EXPECTED_ANY> & KnownStatsChunkOrigin} StatsChunkOrigin */
+/** @typedef {KnownStatsChunkOrigin & Record<string, EXPECTED_ANY>} StatsChunkOrigin */
 /**
  * @typedef {object} KnownStatsChunkOrigin
  * @property {string} module
@@ -258,10 +270,10 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {string} moduleName
  * @property {string} loc
  * @property {string} request
- * @property {(string | number)=} moduleId
+ * @property {ModuleId=} moduleId
  */
 
-/** @typedef { Record<string, EXPECTED_ANY> & KnownStatsModuleTraceItem} StatsModuleTraceItem */
+/** @typedef {KnownStatsModuleTraceItem & Record<string, EXPECTED_ANY>} StatsModuleTraceItem */
 /**
  * @typedef {object} KnownStatsModuleTraceItem
  * @property {string=} originIdentifier
@@ -269,17 +281,17 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {string=} moduleIdentifier
  * @property {string=} moduleName
  * @property {StatsModuleTraceDependency[]=} dependencies
- * @property {(string|number)=} originId
- * @property {(string|number)=} moduleId
+ * @property {ModuleId=} originId
+ * @property {ModuleId=} moduleId
  */
 
-/** @typedef {Record<string, EXPECTED_ANY> & KnownStatsModuleTraceDependency} StatsModuleTraceDependency */
+/** @typedef {KnownStatsModuleTraceDependency & Record<string, EXPECTED_ANY>} StatsModuleTraceDependency */
 /**
  * @typedef {object} KnownStatsModuleTraceDependency
  * @property {string=} loc
  */
 
-/** @typedef {Record<string, EXPECTED_ANY> & KnownStatsError} StatsError */
+/** @typedef {KnownStatsError & Record<string, EXPECTED_ANY>} StatsError */
 /**
  * @typedef {object} KnownStatsError
  * @property {string} message
@@ -291,10 +303,13 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {string=} moduleName
  * @property {string=} loc
  * @property {ChunkId=} chunkId
- * @property {string|number=} moduleId
+ * @property {ModuleId=} moduleId
  * @property {StatsModuleTraceItem[]=} moduleTrace
- * @property {any=} details
+ * @property {string=} details
  * @property {string=} stack
+ * @property {KnownStatsError=} cause
+ * @property {KnownStatsError[]=} errors
+ * @property {string=} compilerPath
  */
 
 /** @typedef {Asset & { type: string, related: PreprocessedAsset[] | undefined }} PreprocessedAsset */
@@ -305,12 +320,15 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @typedef {Record<string, (object: O, data: T, context: StatsFactoryContext, options: NormalizedStatsOptions, factory: StatsFactory) => void>} ExtractorsByOption
  */
 
+/** @typedef {{ name: string, chunkGroup: ChunkGroup }} ChunkGroupInfoWithName */
+/** @typedef {{ origin: Module, module: Module }} ModuleTrace */
+
 /**
  * @typedef {object} SimpleExtractors
  * @property {ExtractorsByOption<Compilation, StatsCompilation>} compilation
  * @property {ExtractorsByOption<PreprocessedAsset, StatsAsset>} asset
  * @property {ExtractorsByOption<PreprocessedAsset, StatsAsset>} asset$visible
- * @property {ExtractorsByOption<{ name: string, chunkGroup: ChunkGroup }, StatsChunkGroup>} chunkGroup
+ * @property {ExtractorsByOption<ChunkGroupInfoWithName, StatsChunkGroup>} chunkGroup
  * @property {ExtractorsByOption<Module, StatsModule>} module
  * @property {ExtractorsByOption<Module, StatsModule>} module$visible
  * @property {ExtractorsByOption<Module, StatsModuleIssuer>} moduleIssuer
@@ -320,7 +338,8 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {ExtractorsByOption<OriginRecord, StatsChunkOrigin>} chunkOrigin
  * @property {ExtractorsByOption<WebpackError, StatsError>} error
  * @property {ExtractorsByOption<WebpackError, StatsError>} warning
- * @property {ExtractorsByOption<{ origin: Module, module: Module }, StatsModuleTraceItem>} moduleTraceItem
+ * @property {ExtractorsByOption<WebpackError, StatsError>} cause
+ * @property {ExtractorsByOption<ModuleTrace, StatsModuleTraceItem>} moduleTraceItem
  * @property {ExtractorsByOption<Dependency, StatsModuleTraceDependency>} moduleTraceDependency
  */
 
@@ -328,7 +347,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @template T
  * @template I
  * @param {Iterable<T>} items items to select from
- * @param {function(T): Iterable<I>} selector selector function to select values from item
+ * @param {(item: T) => Iterable<I>} selector selector function to select values from item
  * @returns {I[]} array of values
  */
 const uniqueArray = (items, selector) => {
@@ -339,27 +358,31 @@ const uniqueArray = (items, selector) => {
 			set.add(i);
 		}
 	}
-	return Array.from(set);
+	return [...set];
 };
 
 /**
  * @template T
  * @template I
  * @param {Iterable<T>} items items to select from
- * @param {function(T): Iterable<I>} selector selector function to select values from item
+ * @param {(item: T) => Iterable<I>} selector selector function to select values from item
  * @param {Comparator<I>} comparator comparator function
  * @returns {I[]} array of values
  */
 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
+ * @typedef {{ [P in keyof T]: R }} MappedValues<T, 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
+ * @param {(value: T[keyof T], key: keyof T) => R} fn mapping function
  * @returns {MappedValues<T, R>} mapped object
  */
 const mapObject = (obj, fn) => {
@@ -374,8 +397,9 @@ const mapObject = (obj, fn) => {
 };
 
 /**
+ * @template T
  * @param {Compilation} compilation the compilation
- * @param {function(Compilation, string): any[]} getItems get items
+ * @param {(compilation: Compilation, name: string) => T[]} getItems get items
  * @returns {number} total number
  */
 const countWithChildren = (compilation, getItems) => {
@@ -388,53 +412,72 @@ const countWithChildren = (compilation, getItems) => {
 	return count;
 };
 
-/** @type {ExtractorsByOption<WebpackError | string, StatsError>} */
+/** @type {ExtractorsByOption<string | ErrorWithCause | AggregateError | WebpackError, StatsError>} */
 const EXTRACT_ERROR = {
 	_: (object, error, context, { requestShortener }) => {
 		// TODO webpack 6 disallow strings in the errors/warnings list
 		if (typeof error === "string") {
 			object.message = error;
 		} else {
-			if (error.chunk) {
-				object.chunkName = error.chunk.name;
-				object.chunkEntry = error.chunk.hasRuntime();
-				object.chunkInitial = error.chunk.canBeInitial();
+			if (/** @type {WebpackError} */ (error).chunk) {
+				const chunk = /** @type {WebpackError} */ (error).chunk;
+				object.chunkName =
+					/** @type {string | undefined} */
+					(chunk.name);
+				object.chunkEntry = chunk.hasRuntime();
+				object.chunkInitial = chunk.canBeInitial();
 			}
-			if (error.file) {
-				object.file = error.file;
+
+			if (/** @type {WebpackError} */ (error).file) {
+				object.file = /** @type {WebpackError} */ (error).file;
 			}
-			if (error.module) {
-				object.moduleIdentifier = error.module.identifier();
-				object.moduleName = error.module.readableIdentifier(requestShortener);
+
+			if (/** @type {WebpackError} */ (error).module) {
+				object.moduleIdentifier =
+					/** @type {WebpackError} */
+					(error).module.identifier();
+				object.moduleName =
+					/** @type {WebpackError} */
+					(error).module.readableIdentifier(requestShortener);
 			}
-			if (error.loc) {
-				object.loc = formatLocation(error.loc);
+
+			if (/** @type {WebpackError} */ (error).loc) {
+				object.loc = formatLocation(/** @type {WebpackError} */ (error).loc);
 			}
+
 			object.message = error.message;
 		}
 	},
 	ids: (object, error, { compilation: { chunkGraph } }) => {
 		if (typeof error !== "string") {
-			if (error.chunk) {
-				object.chunkId = /** @type {ChunkId} */ (error.chunk.id);
+			if (/** @type {WebpackError} */ (error).chunk) {
+				object.chunkId = /** @type {ChunkId} */ (
+					/** @type {WebpackError} */
+					(error).chunk.id
+				);
 			}
-			if (error.module) {
+
+			if (/** @type {WebpackError} */ (error).module) {
 				object.moduleId =
 					/** @type {ModuleId} */
-					(chunkGraph.getModuleId(error.module));
+					(chunkGraph.getModuleId(/** @type {WebpackError} */ (error).module));
 			}
 		}
 	},
 	moduleTrace: (object, error, context, options, factory) => {
-		if (typeof error !== "string" && error.module) {
+		if (
+			typeof error !== "string" &&
+			/** @type {WebpackError} */ (error).module
+		) {
 			const {
 				type,
 				compilation: { moduleGraph }
 			} = context;
 			/** @type {Set<Module>} */
 			const visitedModules = new Set();
+			/** @type {ModuleTrace[]} */
 			const moduleTrace = [];
-			let current = error.module;
+			let current = /** @type {WebpackError} */ (error).module;
 			while (current) {
 				if (visitedModules.has(current)) break; // circular (technically impossible, but how knows)
 				visitedModules.add(current);
@@ -453,7 +496,7 @@ const EXTRACT_ERROR = {
 	errorDetails: (
 		object,
 		error,
-		{ type, compilation, cachedGetErrors, cachedGetWarnings },
+		{ type, compilation, cachedGetErrors },
 		{ errorDetails }
 	) => {
 		if (
@@ -461,13 +504,44 @@ const EXTRACT_ERROR = {
 			(errorDetails === true ||
 				(type.endsWith(".error") && cachedGetErrors(compilation).length < 3))
 		) {
-			object.details = error.details;
+			object.details = /** @type {WebpackError} */ (error).details;
 		}
 	},
 	errorStack: (object, error) => {
 		if (typeof error !== "string") {
 			object.stack = error.stack;
 		}
+	},
+	errorCause: (object, error, context, options, factory) => {
+		if (
+			typeof error !== "string" &&
+			/** @type {ErrorWithCause} */ (error).cause
+		) {
+			const rawCause = /** @type {ErrorWithCause} */ (error).cause;
+			/** @type {Error} */
+			const cause =
+				typeof rawCause === "string"
+					? /** @type {Error} */ ({ message: rawCause })
+					: /** @type {Error} */ (rawCause);
+			const { type } = context;
+
+			object.cause = factory.create(`${type}.cause`, cause, context);
+		}
+	},
+	errorErrors: (object, error, context, options, factory) => {
+		if (
+			typeof error !== "string" &&
+			/** @type {AggregateError} */
+			(error).errors
+		) {
+			const { type } = context;
+			object.errors = factory.create(
+				`${type}.errors`,
+				/** @type {Error[]} */
+				(/** @type {AggregateError} */ (error).errors),
+				context
+			);
+		}
 	}
 };
 
@@ -482,20 +556,22 @@ const SIMPLE_EXTRACTORS = {
 				);
 			}
 			if (!context.cachedGetErrors) {
+				/** @type {WeakMap<Compilation, Error[]>} */
 				const map = new WeakMap();
-				context.cachedGetErrors = compilation =>
+				context.cachedGetErrors = (compilation) =>
 					map.get(compilation) ||
 					// eslint-disable-next-line no-sequences
-					(errors => (map.set(compilation, errors), errors))(
+					((errors) => (map.set(compilation, errors), errors))(
 						compilation.getErrors()
 					);
 			}
 			if (!context.cachedGetWarnings) {
+				/** @type {WeakMap<Compilation, Error[]>} */
 				const map = new WeakMap();
-				context.cachedGetWarnings = compilation =>
+				context.cachedGetWarnings = (compilation) =>
 					map.get(compilation) ||
 					// eslint-disable-next-line no-sequences
-					(warnings => (map.set(compilation, warnings), warnings))(
+					((warnings) => (map.set(compilation, warnings), warnings))(
 						compilation.getWarnings()
 					);
 			}
@@ -509,6 +585,7 @@ const SIMPLE_EXTRACTORS = {
 			const { logging, loggingDebug, loggingTrace } = options;
 			if (logging || (loggingDebug && loggingDebug.length > 0)) {
 				const util = require("util");
+
 				object.logging = {};
 				let acceptedTypes;
 				let collapsedGroups = false;
@@ -565,7 +642,7 @@ const SIMPLE_EXTRACTORS = {
 				);
 				let depthInCollapsedGroup = 0;
 				for (const [origin, logEntries] of compilation.logging) {
-					const debugMode = loggingDebug.some(fn => fn(origin));
+					const debugMode = loggingDebug.some((fn) => fn(origin));
 					if (logging === false && !debugMode) continue;
 					/** @type {KnownStatsLoggingEntry[]} */
 					const groupStack = [];
@@ -581,8 +658,9 @@ const SIMPLE_EXTRACTORS = {
 						if (
 							type === LogType.groupCollapsed &&
 							(debugMode || collapsedGroups)
-						)
+						) {
 							type = LogType.group;
+						}
 
 						if (depthInCollapsedGroup === 0) {
 							processedLogEntries++;
@@ -647,9 +725,9 @@ const SIMPLE_EXTRACTORS = {
 			}
 		},
 		hash: (object, compilation) => {
-			object.hash = /** @type {string} */ (compilation.hash);
+			object.hash = compilation.hash;
 		},
-		version: object => {
+		version: (object) => {
 			object.version = require("../../package.json").version;
 		},
 		env: (object, compilation, context, { _env }) => {
@@ -665,14 +743,11 @@ const SIMPLE_EXTRACTORS = {
 		},
 		publicPath: (object, compilation) => {
 			object.publicPath = compilation.getPath(
-				/** @type {TemplatePath} */
-				(compilation.outputOptions.publicPath)
+				compilation.outputOptions.publicPath
 			);
 		},
 		outputPath: (object, compilation) => {
-			object.outputPath = /** @type {string} */ (
-				compilation.outputOptions.path
-			);
+			object.outputPath = compilation.outputOptions.path;
 		},
 		assets: (object, compilation, context, options, factory) => {
 			const { type } = context;
@@ -721,6 +796,7 @@ const SIMPLE_EXTRACTORS = {
 						? relatedEntry
 						: [relatedEntry];
 					for (const dep of deps) {
+						if (!dep) continue;
 						const depItem = assetMap.get(dep);
 						if (!depItem) continue;
 						assets.delete(depItem);
@@ -732,7 +808,10 @@ const SIMPLE_EXTRACTORS = {
 			}
 
 			object.assetsByChunkName = {};
-			for (const [file, chunks] of compilationFileToChunks) {
+			for (const [file, chunks] of [
+				...compilationFileToChunks,
+				...compilationAuxiliaryFileToChunks
+			]) {
 				for (const chunk of chunks) {
 					const name = chunk.name;
 					if (!name) continue;
@@ -748,15 +827,11 @@ const SIMPLE_EXTRACTORS = {
 				}
 			}
 
-			const groupedAssets = factory.create(
-				`${type}.assets`,
-				Array.from(assets),
-				{
-					...context,
-					compilationFileToChunks,
-					compilationAuxiliaryFileToChunks
-				}
-			);
+			const groupedAssets = factory.create(`${type}.assets`, [...assets], {
+				...context,
+				compilationFileToChunks,
+				compilationAuxiliaryFileToChunks
+			});
 			const limited = spaceLimited(
 				groupedAssets,
 				/** @type {number} */ (options.assetsSpace)
@@ -768,13 +843,13 @@ const SIMPLE_EXTRACTORS = {
 			const { type } = context;
 			object.chunks = factory.create(
 				`${type}.chunks`,
-				Array.from(compilation.chunks),
+				[...compilation.chunks],
 				context
 			);
 		},
 		modules: (object, compilation, context, options, factory) => {
 			const { type } = context;
-			const array = Array.from(compilation.modules);
+			const array = [...compilation.modules];
 			const groupedModules = factory.create(`${type}.modules`, array, context);
 			const limited = spaceLimited(groupedModules, options.modulesSpace);
 			object.modules = limited.children;
@@ -788,6 +863,7 @@ const SIMPLE_EXTRACTORS = {
 			factory
 		) => {
 			const { type } = context;
+			/** @type {ChunkGroupInfoWithName[]} */
 			const array = Array.from(compilation.entrypoints, ([key, value]) => ({
 				name: key,
 				chunkGroup: value
@@ -840,7 +916,10 @@ const SIMPLE_EXTRACTORS = {
 			let filtered = 0;
 			if (options.errorDetails === "auto" && rawErrors.length >= 3) {
 				filtered = rawErrors
-					.map(e => typeof e !== "string" && e.details)
+					.map(
+						(e) =>
+							typeof e !== "string" && /** @type {WebpackError} */ (e).details
+					)
 					.filter(Boolean).length;
 			}
 			if (
@@ -860,7 +939,7 @@ const SIMPLE_EXTRACTORS = {
 			object.errors = errors;
 		},
 		errorsCount: (object, compilation, { cachedGetErrors }) => {
-			object.errorsCount = countWithChildren(compilation, c =>
+			object.errorsCount = countWithChildren(compilation, (c) =>
 				cachedGetErrors(c)
 			);
 		},
@@ -874,7 +953,10 @@ const SIMPLE_EXTRACTORS = {
 			let filtered = 0;
 			if (options.errorDetails === "auto") {
 				filtered = cachedGetWarnings(compilation)
-					.map(e => typeof e !== "string" && e.details)
+					.map(
+						(e) =>
+							typeof e !== "string" && /** @type {WebpackError} */ (e).details
+					)
 					.filter(Boolean).length;
 			}
 			if (
@@ -904,25 +986,27 @@ const SIMPLE_EXTRACTORS = {
 			object.warningsCount = countWithChildren(compilation, (c, childType) => {
 				if (
 					!warningsFilter &&
-					/** @type {((warning: StatsError, textValue: string) => boolean)[]} */
+					/** @type {KnownNormalizedStatsOptions["warningsFilter"]} */
 					(warningsFilter).length === 0
-				)
-					return cachedGetWarnings(c);
+				) {
+					// Type is wrong, because we don't need the real value for counting
+					return /** @type {EXPECTED_ANY[]} */ (cachedGetWarnings(c));
+				}
 				return factory
 					.create(`${type}${childType}.warnings`, cachedGetWarnings(c), context)
 					.filter(
 						/**
-						 * @param {TODO} warning warning
+						 * @param {StatsError} warning warning
 						 * @returns {boolean} result
 						 */
-						warning => {
+						(warning) => {
 							const warningString = Object.keys(warning)
 								.map(
-									key =>
+									(key) =>
 										`${warning[/** @type {keyof KnownStatsError} */ (key)]}`
 								)
 								.join("\n");
-							return !warningsFilter.some(filter =>
+							return !warningsFilter.some((filter) =>
 								filter(warning, warningString)
 							);
 						}
@@ -963,29 +1047,29 @@ const SIMPLE_EXTRACTORS = {
 		_: (
 			object,
 			asset,
-			{ compilation, compilationFileToChunks, compilationAuxiliaryFileToChunks }
+			{ compilationFileToChunks, compilationAuxiliaryFileToChunks }
 		) => {
 			const chunks = compilationFileToChunks.get(asset.name) || [];
 			const auxiliaryChunks =
 				compilationAuxiliaryFileToChunks.get(asset.name) || [];
 			object.chunkNames = uniqueOrderedArray(
 				chunks,
-				c => (c.name ? [c.name] : []),
+				(c) => (c.name ? [c.name] : []),
 				compareIds
 			);
 			object.chunkIdHints = uniqueOrderedArray(
 				chunks,
-				c => Array.from(c.idNameHints),
+				(c) => [...c.idNameHints],
 				compareIds
 			);
 			object.auxiliaryChunkNames = uniqueOrderedArray(
 				auxiliaryChunks,
-				c => (c.name ? [c.name] : []),
+				(c) => (c.name ? [c.name] : []),
 				compareIds
 			);
 			object.auxiliaryChunkIdHints = uniqueOrderedArray(
 				auxiliaryChunks,
-				c => Array.from(c.idNameHints),
+				(c) => [...c.idNameHints],
 				compareIds
 			);
 			object.filteredRelated = asset.related ? asset.related.length : undefined;
@@ -1012,12 +1096,12 @@ const SIMPLE_EXTRACTORS = {
 				compilationAuxiliaryFileToChunks.get(asset.name) || [];
 			object.chunks = uniqueOrderedArray(
 				chunks,
-				c => /** @type {ChunkId[]} */ (c.ids),
+				(c) => /** @type {ChunkId[]} */ (c.ids),
 				compareIds
 			);
 			object.auxiliaryChunks = uniqueOrderedArray(
 				auxiliaryChunks,
-				c => /** @type {ChunkId[]} */ (c.ids),
+				(c) => /** @type {ChunkId[]} */ (c.ids),
 				compareIds
 			);
 		},
@@ -1039,7 +1123,7 @@ const SIMPLE_EXTRACTORS = {
 			 * @param {string} name Name
 			 * @returns {{ name: string, size: number }} Asset object
 			 */
-			const toAsset = name => {
+			const toAsset = (name) => {
 				const asset = compilation.getAsset(name);
 				return {
 					name,
@@ -1048,10 +1132,12 @@ const SIMPLE_EXTRACTORS = {
 			};
 			/** @type {(total: number, asset: { size: number }) => number} */
 			const sizeReducer = (total, { size }) => total + size;
-			const assets = uniqueArray(chunkGroup.chunks, c => c.files).map(toAsset);
+			const assets = uniqueArray(chunkGroup.chunks, (c) => c.files).map(
+				toAsset
+			);
 			const auxiliaryAssets = uniqueOrderedArray(
 				chunkGroup.chunks,
-				c => c.auxiliaryFiles,
+				(c) => c.auxiliaryFiles,
 				compareIds
 			).map(toAsset);
 			const assetsSize = assets.reduce(sizeReducer, 0);
@@ -1060,7 +1146,7 @@ const SIMPLE_EXTRACTORS = {
 			const statsChunkGroup = {
 				name,
 				chunks: ids
-					? /** @type {ChunkId[]} */ (chunkGroup.chunks.map(c => c.id))
+					? /** @type {ChunkId[]} */ (chunkGroup.chunks.map((c) => c.id))
 					: undefined,
 				assets: assets.length <= chunkGroupMaxAssets ? assets : undefined,
 				filteredAssets:
@@ -1076,14 +1162,14 @@ const SIMPLE_EXTRACTORS = {
 						: auxiliaryAssets.length,
 				auxiliaryAssetsSize,
 				children: children
-					? mapObject(children, groups =>
-							groups.map(group => {
-								const assets = uniqueArray(group.chunks, c => c.files).map(
+					? mapObject(children, (groups) =>
+							groups.map((group) => {
+								const assets = uniqueArray(group.chunks, (c) => c.files).map(
 									toAsset
 								);
 								const auxiliaryAssets = uniqueOrderedArray(
 									group.chunks,
-									c => c.auxiliaryFiles,
+									(c) => c.auxiliaryFiles,
 									compareIds
 								).map(toAsset);
 
@@ -1092,7 +1178,7 @@ const SIMPLE_EXTRACTORS = {
 									name: group.name,
 									chunks: ids
 										? /** @type {ChunkId[]} */
-											(group.chunks.map(c => c.id))
+											(group.chunks.map((c) => c.id))
 										: undefined,
 									assets:
 										assets.length <= chunkGroupMaxAssets ? assets : undefined,
@@ -1115,7 +1201,7 @@ const SIMPLE_EXTRACTORS = {
 						)
 					: undefined,
 				childAssets: children
-					? mapObject(children, groups => {
+					? mapObject(children, (groups) => {
 							/** @type {Set<string>} */
 							const set = new Set();
 							for (const group of groups) {
@@ -1125,7 +1211,7 @@ const SIMPLE_EXTRACTORS = {
 									}
 								}
 							}
-							return Array.from(set);
+							return [...set];
 						})
 					: undefined
 			};
@@ -1161,7 +1247,6 @@ const SIMPLE_EXTRACTORS = {
 				cached: !built && !codeGenerated
 			};
 			Object.assign(object, statsModule);
-
 			if (built || codeGenerated || options.cachedModules) {
 				Object.assign(
 					object,
@@ -1175,7 +1260,7 @@ const SIMPLE_EXTRACTORS = {
 			const { type, rootModules } = context;
 			const compilation = /** @type {Compilation} */ (context.compilation);
 			const { moduleGraph } = compilation;
-			/** @type {Module[]} */
+			/** @type {ModuleIssuerPath} */
 			const path = [];
 			const issuer = moduleGraph.getIssuer(module);
 			let current = issuer;
@@ -1213,7 +1298,8 @@ const SIMPLE_EXTRACTORS = {
 				issuerName: issuer && issuer.readableIdentifier(requestShortener),
 				issuerPath:
 					issuer &&
-					factory.create(`${type.slice(0, -8)}.issuerPath`, path, context),
+					/** @type {StatsModuleIssuer[] | undefined} */
+					(factory.create(`${type.slice(0, -8)}.issuerPath`, path, context)),
 				failed: errorsCount > 0,
 				errors: errorsCount,
 				warnings: warningsCount
@@ -1239,7 +1325,7 @@ const SIMPLE_EXTRACTORS = {
 							module,
 							compareChunksById
 						),
-						chunk => chunk.id
+						(chunk) => chunk.id
 					)
 				);
 		},
@@ -1255,7 +1341,7 @@ const SIMPLE_EXTRACTORS = {
 			} = context;
 			const groupsReasons = factory.create(
 				`${type.slice(0, -8)}.reasons`,
-				Array.from(moduleGraph.getIncomingConnections(module)),
+				[...moduleGraph.getIncomingConnections(module)],
 				context
 			);
 			const limited = spaceLimited(
@@ -1277,7 +1363,7 @@ const SIMPLE_EXTRACTORS = {
 			} else if (typeof usedExports === "boolean") {
 				object.usedExports = usedExports;
 			} else {
-				object.usedExports = Array.from(usedExports);
+				object.usedExports = [...usedExports];
 			}
 		},
 		providedExports: (object, module, { compilation: { moduleGraph } }) => {
@@ -1294,7 +1380,7 @@ const SIMPLE_EXTRACTORS = {
 		) => {
 			object.optimizationBailout = moduleGraph
 				.getOptimizationBailout(module)
-				.map(item => {
+				.map((item) => {
 					if (typeof item === "function") return item(requestShortener);
 					return item;
 				});
@@ -1431,15 +1517,15 @@ const SIMPLE_EXTRACTORS = {
 				size: chunkGraph.getChunkModulesSize(chunk),
 				sizes: chunkGraph.getChunkModulesSizes(chunk),
 				names: chunk.name ? [chunk.name] : [],
-				idHints: Array.from(chunk.idNameHints),
+				idHints: [...chunk.idNameHints],
 				runtime:
 					chunk.runtime === undefined
 						? undefined
 						: typeof chunk.runtime === "string"
 							? [makePathsRelative(chunk.runtime)]
 							: Array.from(chunk.runtime.sort(), makePathsRelative),
-				files: Array.from(chunk.files),
-				auxiliaryFiles: Array.from(chunk.auxiliaryFiles).sort(compareIds),
+				files: [...chunk.files],
+				auxiliaryFiles: [...chunk.auxiliaryFiles].sort(compareIds),
 				hash: /** @type {string} */ (chunk.renderedHash),
 				childrenByOrder: childIdByOrder
 			};
@@ -1448,12 +1534,13 @@ const SIMPLE_EXTRACTORS = {
 		ids: (object, chunk) => {
 			object.id = /** @type {ChunkId} */ (chunk.id);
 		},
-		chunkRelations: (object, chunk, { compilation: { chunkGraph } }) => {
-			/** @type {Set<string|number>} */
+		chunkRelations: (object, chunk, _context) => {
+			/** @typedef {Set<ChunkId>} ChunkRelations */
+			/** @type {ChunkRelations} */
 			const parents = new Set();
-			/** @type {Set<string|number>} */
+			/** @type {ChunkRelations} */
 			const children = new Set();
-			/** @type {Set<string|number>} */
+			/** @type {ChunkRelations} */
 			const siblings = new Set();
 
 			for (const chunkGroup of chunk.groupsIterable) {
@@ -1468,13 +1555,14 @@ const SIMPLE_EXTRACTORS = {
 					}
 				}
 				for (const sibling of chunkGroup.chunks) {
-					if (sibling !== chunk)
+					if (sibling !== chunk) {
 						siblings.add(/** @type {ChunkId} */ (sibling.id));
+					}
 				}
 			}
-			object.siblings = Array.from(siblings).sort(compareIds);
-			object.parents = Array.from(parents).sort(compareIds);
-			object.children = Array.from(children).sort(compareIds);
+			object.siblings = [...siblings].sort(compareIds);
+			object.parents = [...parents].sort(compareIds);
+			object.children = [...children].sort(compareIds);
 		},
 		chunkModules: (object, chunk, context, options, factory) => {
 			const {
@@ -1498,11 +1586,12 @@ const SIMPLE_EXTRACTORS = {
 			} = context;
 			/** @type {Set<string>} */
 			const originsKeySet = new Set();
+			/** @type {OriginRecord[]} */
 			const origins = [];
 			for (const g of chunk.groupsIterable) {
 				origins.push(...g.origins);
 			}
-			const array = origins.filter(origin => {
+			const array = origins.filter((origin) => {
 				const key = [
 					origin.module ? chunkGraph.getModuleId(origin.module) : undefined,
 					formatLocation(origin.loc),
@@ -1537,6 +1626,7 @@ const SIMPLE_EXTRACTORS = {
 	},
 	error: EXTRACT_ERROR,
 	warning: EXTRACT_ERROR,
+	cause: EXTRACT_ERROR,
 	moduleTraceItem: {
 		_: (object, { origin, module }, context, { requestShortener }, factory) => {
 			const {
@@ -1547,14 +1637,13 @@ const SIMPLE_EXTRACTORS = {
 			object.originName = origin.readableIdentifier(requestShortener);
 			object.moduleIdentifier = module.identifier();
 			object.moduleName = module.readableIdentifier(requestShortener);
-			const dependencies = Array.from(
-				moduleGraph.getIncomingConnections(module)
-			)
-				.filter(c => c.resolvedOriginModule === origin && c.dependency)
-				.map(c => c.dependency);
+			const dependencies = [...moduleGraph.getIncomingConnections(module)]
+				.filter((c) => c.resolvedOriginModule === origin && c.dependency)
+				.map((c) => c.dependency);
 			object.dependencies = factory.create(
 				`${type}.dependencies`,
-				Array.from(new Set(dependencies)),
+				/** @type {Dependency[]} */
+				([...new Set(dependencies)]),
 				context
 			);
 		},
@@ -1574,7 +1663,7 @@ const SIMPLE_EXTRACTORS = {
 	}
 };
 
-/** @type {Record<string, Record<string, (thing: any, context: StatsFactoryContext, options: NormalizedStatsOptions) => boolean | undefined>>} */
+/** @type {Record<string, Record<string, (thing: ModuleGraphConnection, context: StatsFactoryContext, options: NormalizedStatsOptions, idx: number, i: number) => boolean | undefined>>} */
 const FILTER = {
 	"module.reasons": {
 		"!orphanModules": (reason, { compilation: { chunkGraph } }) => {
@@ -1588,15 +1677,17 @@ const FILTER = {
 	}
 };
 
-/** @type {Record<string, Record<string, (thing: KnownStatsError, context: StatsFactoryContext, options: NormalizedStatsOptions) => boolean | undefined>>} */
+/** @type {Record<string, Record<string, (thing: KnownStatsError, context: StatsFactoryContext, options: NormalizedStatsOptions, idx: number, i: number) => boolean | undefined>>} */
 const FILTER_RESULTS = {
 	"compilation.warnings": {
 		warningsFilter: util.deprecate(
 			(warning, context, { warningsFilter }) => {
 				const warningString = Object.keys(warning)
-					.map(key => `${warning[/** @type {keyof KnownStatsError} */ (key)]}`)
+					.map(
+						(key) => `${warning[/** @type {keyof KnownStatsError} */ (key)]}`
+					)
 					.join("\n");
-				return !warningsFilter.some(filter => filter(warning, warningString));
+				return !warningsFilter.some((filter) => filter(warning, warningString));
 			},
 			"config.stats.warningsFilter is deprecated in favor of config.ignoreWarnings",
 			"DEP_WEBPACK_STATS_WARNINGS_FILTER"
@@ -1604,43 +1695,32 @@ const FILTER_RESULTS = {
 	}
 };
 
-/** @type {Record<string, (comparators: Function[], context: StatsFactoryContext) => void>} */
+/** @type {Record<string, (comparators: Comparator<Module>[], context: StatsFactoryContext) => void>} */
 const MODULES_SORTER = {
 	_: (comparators, { compilation: { moduleGraph } }) => {
 		comparators.push(
-			compareSelect(
-				/**
-				 * @param {Module} m module
-				 * @returns {number | null} depth
-				 */
-				m => moduleGraph.getDepth(m),
-				compareNumbers
-			),
-			compareSelect(
-				/**
-				 * @param {Module} m module
-				 * @returns {number | null} index
-				 */
-				m => moduleGraph.getPreOrderIndex(m),
-				compareNumbers
-			),
-			compareSelect(
-				/**
-				 * @param {Module} m module
-				 * @returns {string} identifier
-				 */
-				m => m.identifier(),
-				compareIds
-			)
+			compareSelect((m) => moduleGraph.getDepth(m), compareNumbers),
+			compareSelect((m) => moduleGraph.getPreOrderIndex(m), compareNumbers),
+			compareSelect((m) => m.identifier(), compareIds)
 		);
 	}
 };
 
-/** @type {Record<string, Record<string, (comparators: Function[], context: StatsFactoryContext) => void>>} */
+/**
+ * @type {{
+ * "compilation.chunks": Record<string, (comparators: Comparator<Chunk>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>,
+ * "compilation.modules": Record<string, (comparators: Comparator<Module>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>,
+ * "chunk.rootModules": Record<string, (comparators: Comparator<Module>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>,
+ * "chunk.modules": Record<string, (comparators: Comparator<Module>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>,
+ * "module.modules": Record<string, (comparators: Comparator<Module>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>,
+ * "module.reasons": Record<string, (comparators: Comparator<ModuleGraphConnection>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>,
+ * "chunk.origins": Record<string, (comparators: Comparator<OriginRecord>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>,
+ * }}
+ */
 const SORTERS = {
 	"compilation.chunks": {
-		_: comparators => {
-			comparators.push(compareSelect(c => c.id, compareIds));
+		_: (comparators) => {
+			comparators.push(compareSelect((c) => c.id, compareIds));
 		}
 	},
 	"compilation.modules": MODULES_SORTER,
@@ -1648,26 +1728,26 @@ const SORTERS = {
 	"chunk.modules": MODULES_SORTER,
 	"module.modules": MODULES_SORTER,
 	"module.reasons": {
-		_: (comparators, { compilation: { chunkGraph } }) => {
+		_: (comparators, _context) => {
 			comparators.push(
-				compareSelect(x => x.originModule, compareModulesByIdentifier)
+				compareSelect((x) => x.originModule, compareModulesByIdentifier)
 			);
 			comparators.push(
-				compareSelect(x => x.resolvedOriginModule, compareModulesByIdentifier)
+				compareSelect((x) => x.resolvedOriginModule, compareModulesByIdentifier)
 			);
 			comparators.push(
 				compareSelect(
-					x => x.dependency,
+					(x) => x.dependency,
 					concatComparators(
 						compareSelect(
 							/**
 							 * @param {Dependency} x dependency
 							 * @returns {DependencyLocation} location
 							 */
-							x => x.loc,
+							(x) => x.loc,
 							compareLocations
 						),
-						compareSelect(x => x.type, compareIds)
+						compareSelect((x) => x.type, compareIds)
 					)
 				)
 			);
@@ -1677,12 +1757,12 @@ const SORTERS = {
 		_: (comparators, { compilation: { chunkGraph } }) => {
 			comparators.push(
 				compareSelect(
-					origin =>
+					(origin) =>
 						origin.module ? chunkGraph.getModuleId(origin.module) : undefined,
 					compareIds
 				),
-				compareSelect(origin => formatLocation(origin.loc), compareIds),
-				compareSelect(origin => origin.request, compareIds)
+				compareSelect((origin) => formatLocation(origin.loc), compareIds),
+				compareSelect((origin) => origin.request, compareIds)
 			);
 		}
 	}
@@ -1690,7 +1770,7 @@ const SORTERS = {
 
 /**
  * @template T
- * @typedef {T & { children: Children<T>[] | undefined, filteredChildren?: number }} Children
+ * @typedef {T & { children?: Children<T>[] | undefined, filteredChildren?: number }} Children
  */
 
 /**
@@ -1698,7 +1778,7 @@ const SORTERS = {
  * @param {Children<T>} item item
  * @returns {number} item size
  */
-const getItemSize = item =>
+const getItemSize = (item) =>
 	// Each item takes 1 line
 	// + the size of the children
 	// + 1 extra line when it has children and filteredChildren
@@ -1713,7 +1793,7 @@ const getItemSize = item =>
  * @param {Children<T>[]} children children
  * @returns {number} total size
  */
-const getTotalSize = children => {
+const getTotalSize = (children) => {
 	let size = 0;
 	for (const child of children) {
 		size += getItemSize(child);
@@ -1726,7 +1806,7 @@ const getTotalSize = children => {
  * @param {Children<T>[]} children children
  * @returns {number} total items
  */
-const getTotalItems = children => {
+const getTotalItems = (children) => {
 	let count = 0;
 	for (const child of children) {
 		if (!child.children && !child.filteredChildren) {
@@ -1744,7 +1824,7 @@ const getTotalItems = children => {
  * @param {Children<T>[]} children children
  * @returns {Children<T>[]} collapsed children
  */
-const collapse = children => {
+const collapse = (children) => {
 	// After collapse each child must take exactly one line
 	const newChildren = [];
 	for (const child of children) {
@@ -1811,7 +1891,7 @@ const spaceLimited = (
 	if (groupsSize + items.length <= max) {
 		// The total size in the current state fits into the max
 		// keep all
-		children = groups.length > 0 ? groups.concat(items) : items;
+		children = groups.length > 0 ? [...groups, ...items] : items;
 	} else if (groups.length === 0) {
 		// slice items to max
 		// inner space marks that lines for filteredChildren already reserved
@@ -1852,7 +1932,7 @@ const spaceLimited = (
 						// So it should always end up being smaller
 						const headerSize = group.filteredChildren ? 2 : 1;
 						const limited = spaceLimited(
-							/** @type {Children<T>} */ (group.children),
+							/** @type {Children<T>[]} */ (group.children),
 							maxGroupSize -
 								// we should use ceil to always feet in max
 								Math.ceil(oversize / groups.length) -
@@ -1874,7 +1954,7 @@ const spaceLimited = (
 					}
 				}
 			}
-			children = groups.concat(items);
+			children = [...groups, ...items];
 		} else if (limit === max) {
 			// If we have only enough space to show one line per group and one line for the filtered items
 			// collapse all groups and items
@@ -1899,15 +1979,16 @@ const errorsSpaceLimit = (errors, max) => {
 	let filtered = 0;
 	// Can not fit into limit
 	// print only messages
-	if (errors.length + 1 >= max)
+	if (errors.length + 1 >= max) {
 		return [
-			errors.map(error => {
+			errors.map((error) => {
 				if (typeof error === "string" || !error.details) return error;
 				filtered++;
 				return { ...error, details: "" };
 			}),
 			filtered
 		];
+	}
 	let fullLength = errors.length;
 	let result = errors;
 
@@ -1924,7 +2005,9 @@ const errorsSpaceLimit = (errors, max) => {
 				const error = errors[i++];
 				result.push({
 					...error,
-					details: error.details.split("\n").slice(0, -overLimit).join("\n"),
+					details:
+						/** @type {string} */
+						(error.details).split("\n").slice(0, -overLimit).join("\n"),
 					filteredDetails: overLimit
 				});
 				filtered = errors.length - i;
@@ -1952,8 +2035,7 @@ const errorsSpaceLimit = (errors, max) => {
 
 /**
  * @template {{ size: number }} T
- * @template {{ size: number }} R
- * @param {(R | T)[]} children children
+ * @param {T[]} children children
  * @param {T[]} assets assets
  * @returns {{ size: number }} asset size
  */
@@ -1965,11 +2047,13 @@ const assetGroup = (children, assets) => {
 	return { size };
 };
 
+/** @typedef {{ size: number, sizes: Record<string, number> }} ModuleGroupBySizeResult */
+
 /**
- * @template {{ size: number, sizes: Record<string, number> }} T
+ * @template {ModuleGroupBySizeResult} T
  * @param {Children<T>[]} children children
  * @param {KnownStatsModule[]} modules modules
- * @returns {{ size: number, sizes: Record<string, number>}} size and sizes
+ * @returns {ModuleGroupBySizeResult} size and sizes
  */
 const moduleGroup = (children, modules) => {
 	let size = 0;
@@ -2006,7 +2090,21 @@ const reasonGroup = (children, reasons) => {
 const GROUP_EXTENSION_REGEXP = /(\.[^.]+?)(?:\?|(?: \+ \d+ modules?)?$)/;
 const GROUP_PATH_REGEXP = /(.+)[/\\][^/\\]+?(?:\?|(?: \+ \d+ modules?)?$)/;
 
-/** @typedef {Record<string, (groupConfigs: GroupConfig<KnownStatsAsset, TODO>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>} AssetsGroupers */
+/** @typedef {{ type: string }} BaseGroup */
+
+/**
+ * @template T
+ * @typedef {BaseGroup & { children: T[], size: number }} BaseGroupWithChildren
+ */
+
+/**
+ * @typedef {{
+ * _: (groupConfigs: GroupConfig<KnownStatsAsset, BaseGroup & { filteredChildren: number, size: number } | BaseGroupWithChildren<KnownStatsAsset>>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void,
+ * groupAssetsByInfo: (groupConfigs: GroupConfig<KnownStatsAsset, BaseGroupWithChildren<KnownStatsAsset>>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void,
+ * groupAssetsByChunk: (groupConfigs: GroupConfig<KnownStatsAsset, BaseGroupWithChildren<KnownStatsAsset>>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void,
+ * excludeAssets: (groupConfigs: GroupConfig<KnownStatsAsset, BaseGroup & { filteredChildren: number, size: number }>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void,
+ * }} AssetsGroupers
+ */
 
 /** @type {AssetsGroupers} */
 const ASSETS_GROUPERS = {
@@ -2017,7 +2115,7 @@ const ASSETS_GROUPERS = {
 		 */
 		const groupByFlag = (name, exclude) => {
 			groupConfigs.push({
-				getKeys: asset => (asset[name] ? ["1"] : undefined),
+				getKeys: (asset) => (asset[name] ? ["1"] : undefined),
 				getOptions: () => ({
 					groupChildren: !exclude,
 					force: exclude
@@ -2053,22 +2151,24 @@ const ASSETS_GROUPERS = {
 		}
 		if (groupAssetsByPath || groupAssetsByExtension) {
 			groupConfigs.push({
-				getKeys: asset => {
+				getKeys: (asset) => {
 					const extensionMatch =
 						groupAssetsByExtension && GROUP_EXTENSION_REGEXP.exec(asset.name);
 					const extension = extensionMatch ? extensionMatch[1] : "";
 					const pathMatch =
 						groupAssetsByPath && GROUP_PATH_REGEXP.exec(asset.name);
 					const path = pathMatch ? pathMatch[1].split(/[/\\]/) : [];
+					/** @type {string[]} */
 					const keys = [];
 					if (groupAssetsByPath) {
 						keys.push(".");
-						if (extension)
+						if (extension) {
 							keys.push(
 								path.length
 									? `${path.join("/")}/*${extension}`
 									: `*${extension}`
 							);
+						}
 						while (path.length > 0) {
 							keys.push(`${path.join("/")}/`);
 							path.pop();
@@ -2087,13 +2187,14 @@ const ASSETS_GROUPERS = {
 			});
 		}
 	},
-	groupAssetsByInfo: (groupConfigs, context, options) => {
+	groupAssetsByInfo: (groupConfigs, _context, _options) => {
 		/**
 		 * @param {string} name name
 		 */
-		const groupByAssetInfoFlag = name => {
+		const groupByAssetInfoFlag = (name) => {
 			groupConfigs.push({
-				getKeys: asset => (asset.info && asset.info[name] ? ["1"] : undefined),
+				getKeys: (asset) =>
+					asset.info && asset.info[name] ? ["1"] : undefined,
 				createGroup: (key, children, assets) => ({
 					type: "assets by info",
 					info: {
@@ -2108,13 +2209,13 @@ const ASSETS_GROUPERS = {
 		groupByAssetInfoFlag("development");
 		groupByAssetInfoFlag("hotModuleReplacement");
 	},
-	groupAssetsByChunk: (groupConfigs, context, options) => {
+	groupAssetsByChunk: (groupConfigs, _context, _options) => {
 		/**
 		 * @param {keyof KnownStatsAsset} name name
 		 */
-		const groupByNames = name => {
+		const groupByNames = (name) => {
 			groupConfigs.push({
-				getKeys: asset => /** @type {string[]} */ (asset[name]),
+				getKeys: (asset) => /** @type {string[]} */ (asset[name]),
 				createGroup: (key, children, assets) => ({
 					type: "assets by chunk",
 					[name]: [key],
@@ -2130,9 +2231,9 @@ const ASSETS_GROUPERS = {
 	},
 	excludeAssets: (groupConfigs, context, { excludeAssets }) => {
 		groupConfigs.push({
-			getKeys: asset => {
+			getKeys: (asset) => {
 				const ident = asset.name;
-				const excluded = excludeAssets.some(fn => fn(ident, asset));
+				const excluded = excludeAssets.some((fn) => fn(ident, asset));
 				if (excluded) return ["excluded"];
 			},
 			getOptions: () => ({
@@ -2148,10 +2249,17 @@ const ASSETS_GROUPERS = {
 	}
 };
 
-/** @typedef {Record<string, (groupConfigs: GroupConfig<KnownStatsModule, TODO>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>} ModulesGroupers */
+/**
+ * @typedef {{
+ * _: (groupConfigs: GroupConfig<KnownStatsModule, BaseGroup & { filteredChildren?: number, children?: KnownStatsModule[], size: number, sizes: Record<string, number> }>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void,
+ * excludeModules: (groupConfigs: GroupConfig<KnownStatsModule, BaseGroup & { filteredChildren: number, size: number, sizes: Record<string, number> }>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void,
+ * }} ModulesGroupers
+ */
 
-/** @type {function("module" | "chunk" | "root-of-chunk" | "nested"): ModulesGroupers} */
-const MODULES_GROUPERS = type => ({
+/**
+ * @type {(type: ExcludeModulesType) => ModulesGroupers}
+ */
+const MODULES_GROUPERS = (type) => ({
 	_: (groupConfigs, context, options) => {
 		/**
 		 * @param {keyof KnownStatsModule} name name
@@ -2160,7 +2268,7 @@ const MODULES_GROUPERS = type => ({
 		 */
 		const groupByFlag = (name, type, exclude) => {
 			groupConfigs.push({
-				getKeys: module => (module[name] ? ["1"] : undefined),
+				getKeys: (module) => (module[name] ? ["1"] : undefined),
 				getOptions: () => ({
 					groupChildren: !exclude,
 					force: exclude
@@ -2169,7 +2277,11 @@ const MODULES_GROUPERS = type => ({
 					type,
 					[name]: Boolean(key),
 					...(exclude ? { filteredChildren: modules.length } : { children }),
-					...moduleGroup(children, modules)
+					...moduleGroup(
+						/** @type {(KnownStatsModule & ModuleGroupBySizeResult)[]} */
+						(children),
+						modules
+					)
 				})
 			});
 		};
@@ -2203,7 +2315,7 @@ const MODULES_GROUPERS = type => ({
 		}
 		if (groupModulesByType || !options.runtimeModules) {
 			groupConfigs.push({
-				getKeys: module => {
+				getKeys: (module) => {
 					if (!module.moduleType) return;
 					if (groupModulesByType) {
 						return [module.moduleType.split("/", 1)[0]];
@@ -2211,7 +2323,7 @@ const MODULES_GROUPERS = type => ({
 						return [WEBPACK_MODULE_TYPE_RUNTIME];
 					}
 				},
-				getOptions: key => {
+				getOptions: (key) => {
 					const exclude =
 						key === WEBPACK_MODULE_TYPE_RUNTIME && !options.runtimeModules;
 					return {
@@ -2226,25 +2338,33 @@ const MODULES_GROUPERS = type => ({
 						type: `${key} modules`,
 						moduleType: key,
 						...(exclude ? { filteredChildren: modules.length } : { children }),
-						...moduleGroup(children, modules)
+						...moduleGroup(
+							/** @type {(KnownStatsModule & ModuleGroupBySizeResult)[]} */
+							(children),
+							modules
+						)
 					};
 				}
 			});
 		}
 		if (groupModulesByLayer) {
 			groupConfigs.push({
-				getKeys: module => /** @type {string[]} */ ([module.layer]),
+				getKeys: (module) => /** @type {string[]} */ ([module.layer]),
 				createGroup: (key, children, modules) => ({
 					type: "modules by layer",
 					layer: key,
 					children,
-					...moduleGroup(children, modules)
+					...moduleGroup(
+						/** @type {(KnownStatsModule & ModuleGroupBySizeResult)[]} */
+						(children),
+						modules
+					)
 				})
 			});
 		}
 		if (groupModulesByPath || groupModulesByExtension) {
 			groupConfigs.push({
-				getKeys: module => {
+				getKeys: (module) => {
 					if (!module.name) return;
 					const resource = parseResource(
 						/** @type {string} */ (module.name.split("!").pop())
@@ -2259,12 +2379,13 @@ const MODULES_GROUPERS = type => ({
 					const path = pathMatch ? pathMatch[1].split(/[/\\]/) : [];
 					const keys = [];
 					if (groupModulesByPath) {
-						if (extension)
+						if (extension) {
 							keys.push(
 								path.length
 									? `${path.join("/")}/*${extension}`
 									: `*${extension}`
 							);
+						}
 						while (path.length > 0) {
 							keys.push(`${path.join("/")}/`);
 							path.pop();
@@ -2284,7 +2405,11 @@ const MODULES_GROUPERS = type => ({
 								: "modules by extension",
 						name: isDataUrl ? key.slice(/* 'data:'.length */ 5) : key,
 						children,
-						...moduleGroup(children, modules)
+						...moduleGroup(
+							/** @type {(KnownStatsModule & ModuleGroupBySizeResult)[]} */
+							(children),
+							modules
+						)
 					};
 				}
 			});
@@ -2292,10 +2417,10 @@ const MODULES_GROUPERS = type => ({
 	},
 	excludeModules: (groupConfigs, context, { excludeModules }) => {
 		groupConfigs.push({
-			getKeys: module => {
+			getKeys: (module) => {
 				const name = module.name;
 				if (name) {
-					const excluded = excludeModules.some(fn => fn(name, module, type));
+					const excluded = excludeModules.some((fn) => fn(name, module, type));
 					if (excluded) return ["1"];
 				}
 			},
@@ -2306,19 +2431,27 @@ const MODULES_GROUPERS = type => ({
 			createGroup: (key, children, modules) => ({
 				type: "hidden modules",
 				filteredChildren: children.length,
-				...moduleGroup(children, modules)
+				...moduleGroup(
+					/** @type {(KnownStatsModule & ModuleGroupBySizeResult)[]} */
+					(children),
+					modules
+				)
 			})
 		});
 	}
 });
 
-/** @typedef {Record<string, (groupConfigs: import("../util/smartGrouping").GroupConfig<KnownStatsModuleReason, TODO>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>} ModuleReasonsGroupers */
+/**
+ * @typedef {{
+ * groupReasonsByOrigin: (groupConfigs: GroupConfig<KnownStatsModuleReason, BaseGroup & { module: string, children: KnownStatsModuleReason[], active: boolean }>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void
+ * }} ModuleReasonsGroupers
+ */
 
 /** @type {ModuleReasonsGroupers} */
 const MODULE_REASONS_GROUPERS = {
-	groupReasonsByOrigin: groupConfigs => {
+	groupReasonsByOrigin: (groupConfigs) => {
 		groupConfigs.push({
-			getKeys: reason => /** @type {string[]} */ ([reason.module]),
+			getKeys: (reason) => /** @type {string[]} */ ([reason.module]),
 			createGroup: (key, children, reasons) => ({
 				type: "from origin",
 				module: key,
@@ -2329,7 +2462,17 @@ const MODULE_REASONS_GROUPERS = {
 	}
 };
 
-/** @type {Record<string, AssetsGroupers | ModulesGroupers | ModuleReasonsGroupers>} */
+/**
+ * @type {{
+ * "compilation.assets": AssetsGroupers,
+ * "asset.related": AssetsGroupers,
+ * "compilation.modules": ModulesGroupers,
+ * "chunk.modules": ModulesGroupers,
+ * "chunk.rootModules": ModulesGroupers,
+ * "module.modules": ModulesGroupers,
+ * "module.reasons": ModuleReasonsGroupers,
+ * }}
+ */
 const RESULT_GROUPERS = {
 	"compilation.assets": ASSETS_GROUPERS,
 	"asset.related": ASSETS_GROUPERS,
@@ -2345,7 +2488,7 @@ const RESULT_GROUPERS = {
  * @param {string} field a field name
  * @returns {field} normalized field
  */
-const normalizeFieldKey = field => {
+const normalizeFieldKey = (field) => {
 	if (field[0] === "!") {
 		return field.slice(1);
 	}
@@ -2357,7 +2500,7 @@ const normalizeFieldKey = field => {
  * @param {string} field a field name
  * @returns {boolean} result
  */
-const sortOrderRegular = field => {
+const sortOrderRegular = (field) => {
 	if (field[0] === "!") {
 		return false;
 	}
@@ -2366,15 +2509,15 @@ const sortOrderRegular = field => {
 
 /**
  * @template T
- * @param {string} field field name
- * @returns {function(T, T): 0 | 1 | -1} comparators
+ * @param {string | false} field field name
+ * @returns {(a: T, b: T) => 0 | 1 | -1} comparators
  */
-const sortByField = field => {
+const sortByField = (field) => {
 	if (!field) {
 		/**
-		 * @param {any} a first
-		 * @param {any} b second
-		 * @returns {-1|0|1} zero
+		 * @param {T} a first
+		 * @param {T} b second
+		 * @returns {-1 | 0 | 1} zero
 		 */
 		const noSort = (a, b) => 0;
 		return noSort;
@@ -2382,7 +2525,7 @@ const sortByField = field => {
 
 	const fieldKey = normalizeFieldKey(field);
 
-	let sortFn = compareSelect(m => m[fieldKey], compareIds);
+	let sortFn = compareSelect((m) => m[fieldKey], compareIds);
 
 	// if a field is prefixed with a "!" the sort is reversed!
 	const sortIsRegular = sortOrderRegular(field);
@@ -2395,17 +2538,33 @@ const sortByField = field => {
 	return sortFn;
 };
 
-/** @type {Record<string, (comparators: Comparator<TODO>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>} */
+/**
+ * @typedef {{
+ * assetsSort: (comparators: Comparator<Asset>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void,
+ * _: (comparators: Comparator<Asset>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void
+ * }} AssetSorters
+ */
+
+/** @type {AssetSorters} */
 const ASSET_SORTERS = {
 	assetsSort: (comparators, context, { assetsSort }) => {
 		comparators.push(sortByField(assetsSort));
 	},
-	_: comparators => {
-		comparators.push(compareSelect(a => a.name, compareIds));
+	_: (comparators) => {
+		comparators.push(compareSelect((a) => a.name, compareIds));
 	}
 };
 
-/** @type {Record<string, Record<string, (comparators: Comparator<TODO>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>>} */
+/**
+ * @type {{
+ * "compilation.chunks": { chunksSort: (comparators: Comparator<Chunk>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void },
+ * "compilation.modules": { modulesSort: (comparators: Comparator<Module>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void },
+ * "chunk.modules": { chunkModulesSort: (comparators: Comparator<Module>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void },
+ * "module.modules": { nestedModulesSort: (comparators: Comparator<Module>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void },
+ * "compilation.assets": AssetSorters,
+ * "asset.related": AssetSorters,
+ * }}
+ */
 const RESULT_SORTERS = {
 	"compilation.chunks": {
 		chunksSort: (comparators, context, { chunksSort }) => {
@@ -2432,9 +2591,15 @@ const RESULT_SORTERS = {
 };
 
 /**
- * @param {Record<string, Record<string, Function>>} config the config see above
+ * @template T
+ * @typedef {T extends Record<string, Record<string, infer F>> ? F : never} ExtractFunction
+ */
+
+/**
+ * @template {Record<string, Record<string, EXPECTED_ANY>>} T
+ * @param {T} config the config see above
  * @param {NormalizedStatsOptions} options stats options
- * @param {function(string, Function): void} fn handler function called for every active line in config
+ * @param {(hookFor: keyof T, fn: ExtractFunction<T>) => void} fn handler function called for every active line in config
  * @returns {void}
  */
 const iterateConfig = (config, options, fn) => {
@@ -2450,8 +2615,9 @@ const iterateConfig = (config, options, fn) => {
 						value === false ||
 						value === undefined ||
 						(Array.isArray(value) && value.length === 0)
-					)
+					) {
 						continue;
+					}
 				}
 			}
 			fn(hookFor, subConfig[option]);
@@ -2467,6 +2633,8 @@ const ITEM_NAMES = {
 	"compilation.namedChunkGroups[]": "chunkGroup",
 	"compilation.errors[]": "error",
 	"compilation.warnings[]": "warning",
+	"error.errors[]": "error",
+	"warning.errors[]": "error",
 	"chunk.modules[]": "module",
 	"chunk.rootModules[]": "module",
 	"chunk.origins[]": "chunkOrigin",
@@ -2491,7 +2659,7 @@ const ITEM_NAMES = {
  * @param {T[]} items items to be merged
  * @returns {NamedObject<T>} an object
  */
-const mergeToObject = items => {
+const mergeToObject = (items) => {
 	const obj = Object.create(null);
 	for (const item of items) {
 		obj[item.name] = item;
@@ -2508,6 +2676,8 @@ const MERGER = {
 	"compilation.namedChunkGroups": mergeToObject
 };
 
+const PLUGIN_NAME = "DefaultStatsFactoryPlugin";
+
 class DefaultStatsFactoryPlugin {
 	/**
 	 * Apply the plugin
@@ -2515,9 +2685,9 @@ class DefaultStatsFactoryPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap("DefaultStatsFactoryPlugin", compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			compilation.hooks.statsFactory.tap(
-				"DefaultStatsFactoryPlugin",
+				PLUGIN_NAME,
 				/**
 				 * @param {StatsFactory} stats stats factory
 				 * @param {NormalizedStatsOptions} options stats options
@@ -2526,61 +2696,59 @@ class DefaultStatsFactoryPlugin {
 					iterateConfig(SIMPLE_EXTRACTORS, options, (hookFor, fn) => {
 						stats.hooks.extract
 							.for(hookFor)
-							.tap("DefaultStatsFactoryPlugin", (obj, data, ctx) =>
+							.tap(PLUGIN_NAME, (obj, data, ctx) =>
 								fn(obj, data, ctx, options, stats)
 							);
 					});
 					iterateConfig(FILTER, options, (hookFor, fn) => {
 						stats.hooks.filter
 							.for(hookFor)
-							.tap("DefaultStatsFactoryPlugin", (item, ctx, idx, i) =>
+							.tap(PLUGIN_NAME, (item, ctx, idx, i) =>
 								fn(item, ctx, options, idx, i)
 							);
 					});
 					iterateConfig(FILTER_RESULTS, options, (hookFor, fn) => {
 						stats.hooks.filterResults
 							.for(hookFor)
-							.tap("DefaultStatsFactoryPlugin", (item, ctx, idx, i) =>
+							.tap(PLUGIN_NAME, (item, ctx, idx, i) =>
 								fn(item, ctx, options, idx, i)
 							);
 					});
 					iterateConfig(SORTERS, options, (hookFor, fn) => {
 						stats.hooks.sort
 							.for(hookFor)
-							.tap("DefaultStatsFactoryPlugin", (comparators, ctx) =>
+							.tap(PLUGIN_NAME, (comparators, ctx) =>
 								fn(comparators, ctx, options)
 							);
 					});
 					iterateConfig(RESULT_SORTERS, options, (hookFor, fn) => {
 						stats.hooks.sortResults
 							.for(hookFor)
-							.tap("DefaultStatsFactoryPlugin", (comparators, ctx) =>
+							.tap(PLUGIN_NAME, (comparators, ctx) =>
 								fn(comparators, ctx, options)
 							);
 					});
 					iterateConfig(RESULT_GROUPERS, options, (hookFor, fn) => {
 						stats.hooks.groupResults
 							.for(hookFor)
-							.tap("DefaultStatsFactoryPlugin", (groupConfigs, ctx) =>
+							.tap(PLUGIN_NAME, (groupConfigs, ctx) =>
 								fn(groupConfigs, ctx, options)
 							);
 					});
 					for (const key of Object.keys(ITEM_NAMES)) {
 						const itemName = ITEM_NAMES[key];
-						stats.hooks.getItemName
-							.for(key)
-							.tap("DefaultStatsFactoryPlugin", () => itemName);
+						stats.hooks.getItemName.for(key).tap(PLUGIN_NAME, () => itemName);
 					}
 					for (const key of Object.keys(MERGER)) {
 						const merger = MERGER[key];
-						stats.hooks.merge.for(key).tap("DefaultStatsFactoryPlugin", merger);
+						stats.hooks.merge.for(key).tap(PLUGIN_NAME, merger);
 					}
 					if (options.children) {
 						if (Array.isArray(options.children)) {
 							stats.hooks.getItemFactory
 								.for("compilation.children[].compilation")
 								.tap(
-									"DefaultStatsFactoryPlugin",
+									PLUGIN_NAME,
 									/**
 									 * @param {Compilation} comp compilation
 									 * @param {StatsFactoryContext} options options
@@ -2588,7 +2756,7 @@ class DefaultStatsFactoryPlugin {
 									 */
 									(comp, { _index: idx }) => {
 										const children =
-											/** @type {TODO} */
+											/** @type {StatsValue[]} */
 											(options.children);
 										if (idx < children.length) {
 											return compilation.createStatsFactory(
@@ -2603,7 +2771,7 @@ class DefaultStatsFactoryPlugin {
 							);
 							stats.hooks.getItemFactory
 								.for("compilation.children[].compilation")
-								.tap("DefaultStatsFactoryPlugin", () => childFactory);
+								.tap(PLUGIN_NAME, () => childFactory);
 						}
 					}
 				}
@@ -2611,4 +2779,5 @@ class DefaultStatsFactoryPlugin {
 		});
 	}
 }
+
 module.exports = DefaultStatsFactoryPlugin;