webpack 5.59.0 → 5.94.0

package/lib/stats/DefaultStatsFactoryPlugin.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const util = require("util");
+const { WEBPACK_MODULE_TYPE_RUNTIME } = require("../ModuleTypeConstants");
 const ModuleDependency = require("../dependencies/ModuleDependency");
 const formatLocation = require("../formatLocation");
 const { LogType } = require("../logging/Logger");
@@ -25,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 */
@@ -32,22 +34,30 @@ 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
+ * @typedef {object} KnownStatsCompilation
  * @property {any=} env
  * @property {string=} name
  * @property {string=} hash
@@ -73,28 +83,28 @@ 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
+ * @typedef {object} KnownStatsLogging
  * @property {StatsLoggingEntry[]} entries
  * @property {number} filteredEntries
  * @property {boolean} debug
  */
 
-/** @typedef {KnownStatsLoggingEntry & Record<string, any>} StatsLoggingEntry */
+/** @typedef {Record<string, any> & KnownStatsLoggingEntry} StatsLoggingEntry */
 /**
- * @typedef {Object} KnownStatsLoggingEntry
+ * @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
+ * @typedef {object} KnownStatsAsset
  * @property {string} type
  * @property {string} name
  * @property {AssetInfo} info
@@ -113,9 +123,9 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {boolean=} isOverSizeLimit
  */
 
-/** @typedef {KnownStatsChunkGroup & Record<string, any>} StatsChunkGroup */
+/** @typedef {Record<string, any> & KnownStatsChunkGroup} StatsChunkGroup */
 /**
- * @typedef {Object} KnownStatsChunkGroup
+ * @typedef {object} KnownStatsChunkGroup
  * @property {string=} name
  * @property {(string|number)[]=} chunks
  * @property {({ name: string, size?: number })[]=} assets
@@ -129,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
+ * @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
@@ -151,31 +161,31 @@ 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
+ * @typedef {object} KnownStatsProfile
  * @property {number} total
  * @property {number} resolving
  * @property {number} restoring
@@ -188,49 +198,49 @@ 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
+ * @typedef {object} KnownStatsModuleIssuer
+ * @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
+ * @typedef {object} KnownStatsModuleReason
+ * @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
+ * @typedef {object} KnownStatsChunk
  * @property {boolean} rendered
  * @property {boolean} initial
  * @property {boolean} entry
  * @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
@@ -240,20 +250,20 @@ 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
+ * @typedef {object} KnownStatsChunkOrigin
+ * @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
+ * @typedef {object} KnownStatsModuleTraceItem
  * @property {string=} originIdentifier
  * @property {string=} originName
  * @property {string=} moduleIdentifier
@@ -263,15 +273,15 @@ 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
+ * @typedef {object} KnownStatsModuleTraceDependency
  * @property {string=} loc
  */
 
-/** @typedef {KnownStatsError & Record<string, any>} StatsError */
+/** @typedef {Record<string, any> & KnownStatsError} StatsError */
 /**
- * @typedef {Object} KnownStatsError
+ * @typedef {object} KnownStatsError
  * @property {string} message
  * @property {string=} chunkName
  * @property {boolean=} chunkEntry
@@ -280,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
@@ -296,7 +306,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  */
 
 /**
- * @typedef {Object} SimpleExtractors
+ * @typedef {object} SimpleExtractors
  * @property {ExtractorsByOption<Compilation, StatsCompilation>} compilation
  * @property {ExtractorsByOption<PreprocessedAsset, StatsAsset>} asset
  * @property {ExtractorsByOption<PreprocessedAsset, StatsAsset>} asset$visible
@@ -340,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
@@ -356,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;
 };
@@ -404,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));
 			}
 		}
 	},
@@ -469,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;
@@ -503,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;
@@ -548,6 +555,9 @@ const SIMPLE_EXTRACTORS = {
 						]);
 						collapsedGroups = true;
 						break;
+					default:
+						acceptedTypes = new Set();
+						break;
 				}
 				const cachedMakePathsRelative = makePathsRelative.bindContextCache(
 					options.context,
@@ -580,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
@@ -635,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;
@@ -644,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;
@@ -740,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;
 		},
@@ -811,11 +830,33 @@ const SIMPLE_EXTRACTORS = {
 		},
 		errors: (object, compilation, context, options, factory) => {
 			const { type, cachedGetErrors } = context;
-			object.errors = factory.create(
+			const rawErrors = cachedGetErrors(compilation);
+			const factorizedErrors = factory.create(
 				`${type}.errors`,
 				cachedGetErrors(compilation),
 				context
 			);
+			let filtered = 0;
+			if (options.errorDetails === "auto" && rawErrors.length >= 3) {
+				filtered = rawErrors
+					.map(e => typeof e !== "string" && e.details)
+					.filter(Boolean).length;
+			}
+			if (
+				options.errorDetails === true ||
+				!Number.isFinite(options.errorsSpace)
+			) {
+				object.errors = factorizedErrors;
+				if (filtered) object.filteredErrorDetailsCount = filtered;
+				return;
+			}
+			const [errors, filteredBySpace] = errorsSpaceLimit(
+				factorizedErrors,
+				/** @type {number} */
+				(options.errorsSpace)
+			);
+			object.filteredErrorDetailsCount = filtered + filteredBySpace;
+			object.errors = errors;
 		},
 		errorsCount: (object, compilation, { cachedGetErrors }) => {
 			object.errorsCount = countWithChildren(compilation, c =>
@@ -824,11 +865,32 @@ const SIMPLE_EXTRACTORS = {
 		},
 		warnings: (object, compilation, context, options, factory) => {
 			const { type, cachedGetWarnings } = context;
-			object.warnings = factory.create(
+			const rawWarnings = factory.create(
 				`${type}.warnings`,
 				cachedGetWarnings(compilation),
 				context
 			);
+			let filtered = 0;
+			if (options.errorDetails === "auto") {
+				filtered = cachedGetWarnings(compilation)
+					.map(e => typeof e !== "string" && e.details)
+					.filter(Boolean).length;
+			}
+			if (
+				options.errorDetails === true ||
+				!Number.isFinite(options.warningsSpace)
+			) {
+				object.warnings = rawWarnings;
+				if (filtered) object.filteredWarningDetailsCount = filtered;
+				return;
+			}
+			const [warnings, filteredBySpace] = errorsSpaceLimit(
+				rawWarnings,
+				/** @type {number} */
+				(options.warningsSpace)
+			);
+			object.filteredWarningDetailsCount = filtered + filteredBySpace;
+			object.warnings = warnings;
 		},
 		warningsCount: (
 			object,
@@ -839,43 +901,33 @@ 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)
+							);
+						}
+					);
 			});
 		},
-		errorDetails: (
-			object,
-			compilation,
-			{ cachedGetErrors, cachedGetWarnings },
-			{ errorDetails, errors, warnings }
-		) => {
-			if (errorDetails === "auto") {
-				if (warnings) {
-					const warnings = cachedGetWarnings(compilation);
-					object.filteredWarningDetailsCount = warnings
-						.map(e => typeof e !== "string" && e.details)
-						.filter(Boolean).length;
-				}
-				if (errors) {
-					const errors = cachedGetErrors(compilation);
-					if (errors.length >= 3) {
-						object.filteredErrorDetailsCount = errors
-							.map(e => typeof e !== "string" && e.details)
-							.filter(Boolean).length;
-					}
-				}
-			}
-		},
 		children: (object, compilation, context, options, factory) => {
 			const { type } = context;
 			object.children = factory.create(
@@ -941,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: (
@@ -956,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
 			);
 		},
@@ -985,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} */
@@ -1001,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,
@@ -1030,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:
@@ -1049,7 +1111,7 @@ const SIMPLE_EXTRACTORS = {
 
 								return childStatsChunkGroup;
 							})
-					  )
+						)
 					: undefined,
 				childAssets: children
 					? mapObject(children, groups => {
@@ -1063,7 +1125,7 @@ const SIMPLE_EXTRACTORS = {
 								}
 							}
 							return Array.from(set);
-					  })
+						})
 					: undefined
 			};
 			Object.assign(object, statsChunkGroup);
@@ -1074,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 =
@@ -1108,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 = [];
@@ -1135,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") &&
@@ -1164,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) => {
@@ -1187,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;
 		},
@@ -1280,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)
@@ -1294,7 +1374,7 @@ const SIMPLE_EXTRACTORS = {
 			}
 		},
 		ids: (object, module, { compilation: { chunkGraph } }) => {
-			object.id = chunkGraph.getModuleId(module);
+			object.id = /** @type {ModuleId} */ (chunkGraph.getModuleId(module));
 		}
 	},
 	moduleReason: {
@@ -1360,17 +1440,17 @@ const SIMPLE_EXTRACTORS = {
 					chunk.runtime === undefined
 						? undefined
 						: typeof chunk.runtime === "string"
-						? [makePathsRelative(chunk.runtime)]
-						: Array.from(chunk.runtime.sort(), makePathsRelative),
+							? [makePathsRelative(chunk.runtime)]
+							: 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>} */
@@ -1383,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);
@@ -1454,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;
 		}
 	},
@@ -1482,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: {
@@ -1507,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));
 			},
@@ -1530,7 +1615,7 @@ const MODULES_SORTER = {
 			compareSelect(
 				/**
 				 * @param {Module} m module
-				 * @returns {number} depth
+				 * @returns {number | null} depth
 				 */
 				m => moduleGraph.getDepth(m),
 				compareNumbers
@@ -1538,7 +1623,7 @@ const MODULES_SORTER = {
 			compareSelect(
 				/**
 				 * @param {Module} m module
-				 * @returns {number} index
+				 * @returns {number | null} index
 				 */
 				m => moduleGraph.getPreOrderIndex(m),
 				compareNumbers
@@ -1607,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);
-};
+			? 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) {
@@ -1626,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) {
@@ -1639,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 = [];
@@ -1658,102 +1767,217 @@ const collapse = children => {
 	return newChildren;
 };
 
-const spaceLimited = (itemsAndGroups, max) => {
-	/** @type {any[] | undefined} */
-	let children = undefined;
+/**
+ * @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 /** @type {Children<T>} */ ({
+			children: undefined,
+			filteredChildren: getTotalItems(itemsAndGroups)
+		});
+	}
+	/** @type {Children<T>[] | undefined} */
+	let children;
 	/** @type {number | undefined} */
-	let filteredChildren = undefined;
+	let filteredChildren;
 	// This are the groups, which take 1+ lines each
-	const groups = itemsAndGroups.filter(c => c.children || c.filteredChildren);
+	/** @type {Children<T>[] | undefined} */
+	const groups = [];
 	// The sizes of the groups are stored in groupSizes
-	const groupSizes = groups.map(g => getItemSize(g));
+	/** @type {number[]} */
+	const groupSizes = [];
 	// This are the items, which take 1 line each
-	const items = itemsAndGroups.filter(c => !c.children && !c.filteredChildren);
+	const items = [];
 	// The total of group sizes
-	let groupsSize = groupSizes.reduce((a, b) => a + b, 0);
+	let groupsSize = 0;
+
+	for (const itemOrGroup of itemsAndGroups) {
+		// is item
+		if (!itemOrGroup.children && !itemOrGroup.filteredChildren) {
+			items.push(itemOrGroup);
+		} else {
+			groups.push(itemOrGroup);
+			const size = getItemSize(itemOrGroup);
+			groupSizes.push(size);
+			groupsSize += size;
+		}
+	}
+
 	if (groupsSize + items.length <= max) {
 		// The total size in the current state fits into the max
 		// keep all
-		children = groups.concat(items);
-	} else if (
-		groups.length > 0 &&
-		groups.length + Math.min(1, items.length) < max
-	) {
-		// If each group would take 1 line the total would be below the maximum
-		// collapse some groups, keep items
-		while (groupsSize + items.length + (filteredChildren ? 1 : 0) > max) {
+		children = groups.length > 0 ? groups.concat(items) : items;
+	} else if (groups.length === 0) {
+		// slice items to max
+		// inner space marks that lines for filteredChildren already reserved
+		const limit = max - (filteredChildrenLineReserved ? 0 : 1);
+		filteredChildren = items.length - limit;
+		items.length = limit;
+		children = items;
+	} else {
+		// limit is the size when all groups are collapsed
+		const limit =
+			groups.length +
+			(filteredChildrenLineReserved || items.length === 0 ? 0 : 1);
+		if (limit < max) {
 			// calculate how much we are over the size limit
 			// this allows to approach the limit faster
-			// it's always > 1
-			const oversize =
-				items.length + groupsSize + (filteredChildren ? 1 : 0) - max;
-			// Find the maximum group and process only this one
-			const maxGroupSize = Math.max(...groupSizes);
-			if (maxGroupSize < items.length) {
-				filteredChildren = items.length;
-				items.length = 0;
-				continue;
+			let oversize;
+			// If each group would take 1 line the total would be below the maximum
+			// collapse some groups, keep items
+			while (
+				(oversize =
+					groupsSize +
+					items.length +
+					(filteredChildren && !filteredChildrenLineReserved ? 1 : 0) -
+					max) > 0
+			) {
+				// Find the maximum group and process only this one
+				const maxGroupSize = Math.max(...groupSizes);
+				if (maxGroupSize < items.length) {
+					filteredChildren = items.length;
+					items.length = 0;
+					continue;
+				}
+				for (let i = 0; i < groups.length; i++) {
+					if (groupSizes[i] === maxGroupSize) {
+						const group = groups[i];
+						// run this algorithm recursively and limit the size of the children to
+						// current size - oversize / number of groups
+						// So it should always end up being smaller
+						const headerSize = group.filteredChildren ? 2 : 1;
+						const limited = spaceLimited(
+							/** @type {Children<T>} */ (group.children),
+							maxGroupSize -
+								// we should use ceil to always feet in max
+								Math.ceil(oversize / groups.length) -
+								// we substitute size of group head
+								headerSize,
+							headerSize === 2
+						);
+						groups[i] = {
+							...group,
+							children: limited.children,
+							filteredChildren: limited.filteredChildren
+								? (group.filteredChildren || 0) + limited.filteredChildren
+								: group.filteredChildren
+						};
+						const newSize = getItemSize(groups[i]);
+						groupsSize -= maxGroupSize - newSize;
+						groupSizes[i] = newSize;
+						break;
+					}
+				}
 			}
-			for (let i = 0; i < groups.length; i++) {
-				if (groupSizes[i] === maxGroupSize) {
-					const group = groups[i];
-					// run this algorithm recursively and limit the size of the children to
-					// current size - oversize / number of groups
-					// So it should always end up being smaller
-					const headerSize = !group.children
-						? 0
-						: group.filteredChildren
-						? 2
-						: 1;
-					const limited = spaceLimited(
-						group.children,
-						groupSizes[i] - headerSize - oversize / groups.length
-					);
-					groups[i] = {
-						...group,
-						children: limited.children,
-						filteredChildren:
-							(group.filteredChildren || 0) + limited.filteredChildren
-					};
-					const newSize = getItemSize(groups[i]);
-					groupsSize -= groupSizes[i] - newSize;
-					groupSizes[i] = newSize;
-					break;
+			children = groups.concat(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
+			children = collapse(groups);
+			filteredChildren = items.length;
+		} else {
+			// If we have no space
+			// collapse complete group
+			filteredChildren = getTotalItems(itemsAndGroups);
+		}
+	}
+
+	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
+	// print only messages
+	if (errors.length + 1 >= max)
+		return [
+			errors.map(error => {
+				if (typeof error === "string" || !error.details) return error;
+				filtered++;
+				return { ...error, details: "" };
+			}),
+			filtered
+		];
+	let fullLength = errors.length;
+	let result = errors;
+
+	let i = 0;
+	for (; i < errors.length; i++) {
+		const error = errors[i];
+		if (typeof error !== "string" && error.details) {
+			const splitted = error.details.split("\n");
+			const len = splitted.length;
+			fullLength += len;
+			if (fullLength > max) {
+				result = i > 0 ? errors.slice(0, i) : [];
+				const overLimit = fullLength - max + 1;
+				const error = errors[i++];
+				result.push({
+					...error,
+					details: error.details.split("\n").slice(0, -overLimit).join("\n"),
+					filteredDetails: overLimit
+				});
+				filtered = errors.length - i;
+				for (; i < errors.length; i++) {
+					const error = errors[i];
+					if (typeof error === "string" || !error.details) result.push(error);
+					result.push({ ...error, details: "" });
 				}
+				break;
+			} else if (fullLength === max) {
+				result = errors.slice(0, ++i);
+				filtered = errors.length - i;
+				for (; i < errors.length; i++) {
+					const error = errors[i];
+					if (typeof error === "string" || !error.details) result.push(error);
+					result.push({ ...error, details: "" });
+				}
+				break;
 			}
 		}
-		children = groups.concat(items);
-	} else if (
-		groups.length > 0 &&
-		groups.length + Math.min(1, items.length) <= 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
-		children = groups.length ? collapse(groups) : undefined;
-		filteredChildren = items.length;
-	} else {
-		// If we have no space
-		// collapse complete group
-		filteredChildren = getTotalItems(itemsAndGroups);
 	}
-	return {
-		children,
-		filteredChildren
-	};
+
+	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;
@@ -1767,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) {
@@ -1777,35 +2007,39 @@ const reasonGroup = (children, reasons) => {
 	};
 };
 
-/** @type {Record<string, (groupConfigs: GroupConfig[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>} */
+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 */
+
+/** @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 {
@@ -1825,10 +2059,10 @@ const ASSETS_GROUPERS = {
 			groupConfigs.push({
 				getKeys: asset => {
 					const extensionMatch =
-						groupAssetsByExtension && /(\.[^.]+)(?:\?.*|$)/.exec(asset.name);
+						groupAssetsByExtension && GROUP_EXTENSION_REGEXP.exec(asset.name);
 					const extension = extensionMatch ? extensionMatch[1] : "";
 					const pathMatch =
-						groupAssetsByPath && /(.+)[/\\][^/\\]+(?:\?.*|$)/.exec(asset.name);
+						groupAssetsByPath && GROUP_PATH_REGEXP.exec(asset.name);
 					const path = pathMatch ? pathMatch[1].split(/[/\\]/) : [];
 					const keys = [];
 					if (groupAssetsByPath) {
@@ -1840,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");
@@ -1882,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");
@@ -1922,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 {
@@ -1980,19 +2211,21 @@ const MODULES_GROUPERS = type => ({
 					if (!module.moduleType) return;
 					if (groupModulesByType) {
 						return [module.moduleType.split("/", 1)[0]];
-					} else if (module.moduleType === "runtime") {
-						return ["runtime"];
+					} else if (module.moduleType === WEBPACK_MODULE_TYPE_RUNTIME) {
+						return [WEBPACK_MODULE_TYPE_RUNTIME];
 					}
 				},
 				getOptions: key => {
-					const exclude = key === "runtime" && !options.runtimeModules;
+					const exclude =
+						key === WEBPACK_MODULE_TYPE_RUNTIME && !options.runtimeModules;
 					return {
 						groupChildren: !exclude,
 						force: exclude
 					};
 				},
 				createGroup: (key, children, modules) => {
-					const exclude = key === "runtime" && !options.runtimeModules;
+					const exclude =
+						key === WEBPACK_MODULE_TYPE_RUNTIME && !options.runtimeModules;
 					return {
 						type: `${key} modules`,
 						moduleType: key,
@@ -2004,29 +2237,29 @@ 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 =
-						groupModulesByExtension && /(\.[^.]+)(?:\?.*|$)/.exec(resource);
+						groupModulesByExtension && GROUP_EXTENSION_REGEXP.exec(resource);
 					const extension = extensionMatch ? extensionMatch[1] : "";
 					const pathMatch =
-						groupModulesByPath && /(.+)[/\\][^/\\]+(?:\?.*|$)/.exec(resource);
+						groupModulesByPath && GROUP_PATH_REGEXP.exec(resource);
 					const path = pathMatch ? pathMatch[1].split(/[/\\]/) : [];
 					const keys = [];
 					if (groupModulesByPath) {
@@ -2037,20 +2270,23 @@ 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;
 				},
 				createGroup: (key, children, modules) => {
+					const isDataUrl = key.startsWith("data:");
 					return {
-						type: groupModulesByPath
-							? "modules by path"
-							: "modules by extension",
-						name: key,
+						type: isDataUrl
+							? "modules by mime type"
+							: groupModulesByPath
+								? "modules by path"
+								: "modules by extension",
+						name: isDataUrl ? key.slice(/* 'data:'.length */ 5) : key,
 						children,
 						...moduleGroup(children, modules)
 					};
@@ -2080,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,
@@ -2088,34 +2341,26 @@ 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.substr(1);
+		return field.slice(1);
 	}
 	return 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;
@@ -2125,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) {
@@ -2153,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));
 	},
@@ -2163,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 }) => {
@@ -2240,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);
@@ -2251,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
@@ -2267,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)
@@ -2324,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);
 						}
 					}
 				}