webpack 5.97.1 → 5.104.1

package/lib/stats/DefaultStatsPrinterPlugin.js

@@ -6,11 +6,31 @@
 "use strict";
 
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../logging/Logger").LogTypeEnum} LogTypeEnum */
+/** @typedef {import("./DefaultStatsFactoryPlugin").ChunkId} ChunkId */
+/** @typedef {import("./DefaultStatsFactoryPlugin").ChunkName} ChunkName */
+/** @typedef {import("./DefaultStatsFactoryPlugin").KnownStatsAsset} KnownStatsAsset */
+/** @typedef {import("./DefaultStatsFactoryPlugin").KnownStatsChunk} KnownStatsChunk */
 /** @typedef {import("./DefaultStatsFactoryPlugin").KnownStatsChunkGroup} KnownStatsChunkGroup */
+/** @typedef {import("./DefaultStatsFactoryPlugin").KnownStatsChunkOrigin} KnownStatsChunkOrigin */
+/** @typedef {import("./DefaultStatsFactoryPlugin").KnownStatsCompilation} KnownStatsCompilation */
+/** @typedef {import("./DefaultStatsFactoryPlugin").KnownStatsError} KnownStatsError */
+/** @typedef {import("./DefaultStatsFactoryPlugin").KnownStatsLogging} KnownStatsLogging */
+/** @typedef {import("./DefaultStatsFactoryPlugin").KnownStatsLoggingEntry} KnownStatsLoggingEntry */
+/** @typedef {import("./DefaultStatsFactoryPlugin").KnownStatsModule} KnownStatsModule */
+/** @typedef {import("./DefaultStatsFactoryPlugin").KnownStatsModuleIssuer} KnownStatsModuleIssuer */
+/** @typedef {import("./DefaultStatsFactoryPlugin").KnownStatsModuleReason} KnownStatsModuleReason */
+/** @typedef {import("./DefaultStatsFactoryPlugin").KnownStatsModuleTraceDependency} KnownStatsModuleTraceDependency */
+/** @typedef {import("./DefaultStatsFactoryPlugin").KnownStatsModuleTraceItem} KnownStatsModuleTraceItem */
+/** @typedef {import("./DefaultStatsFactoryPlugin").KnownStatsProfile} KnownStatsProfile */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsCompilation} StatsCompilation */
 /** @typedef {import("./StatsPrinter")} StatsPrinter */
-/** @typedef {import("./StatsPrinter").KnownStatsPrinterColorFn} KnownStatsPrinterColorFn */
-/** @typedef {import("./StatsPrinter").KnownStatsPrinterFormaters} KnownStatsPrinterFormaters */
+/** @typedef {import("./StatsPrinter").ColorFunction} ColorFunction */
+/** @typedef {import("./StatsPrinter").KnownStatsPrinterColorFunctions} KnownStatsPrinterColorFunctions */
+/** @typedef {import("./StatsPrinter").KnownStatsPrinterContext} KnownStatsPrinterContext */
+/** @typedef {import("./StatsPrinter").KnownStatsPrinterFormatters} KnownStatsPrinterFormatters */
 /** @typedef {import("./StatsPrinter").StatsPrinterContext} StatsPrinterContext */
+/** @typedef {import("./StatsPrinter").StatsPrinterContextWithExtra} StatsPrinterContextWithExtra */
 
 const DATA_URI_CONTENT_LENGTH = 16;
 const MAX_MODULE_IDENTIFIER_LENGTH = 80;
@@ -28,20 +48,21 @@ const plural = (n, singular, plural) => (n === 1 ? singular : plural);
  * @param {StatsPrinterContext} options options
  * @returns {string | undefined} text
  */
-const printSizes = (sizes, { formatSize = n => `${n}` }) => {
+const printSizes = (sizes, { formatSize = (n) => `${n}` }) => {
 	const keys = Object.keys(sizes);
 	if (keys.length > 1) {
-		return keys.map(key => `${formatSize(sizes[key])} (${key})`).join(" ");
+		return keys.map((key) => `${formatSize(sizes[key])} (${key})`).join(" ");
 	} else if (keys.length === 1) {
 		return formatSize(sizes[keys[0]]);
 	}
 };
 
 /**
- * @param {string} resource resource
+ * @param {string | null} resource resource
  * @returns {string} resource name for display
  */
-const getResourceName = resource => {
+const getResourceName = (resource) => {
+	if (!resource) return "";
 	const dataUrl = /^data:[^,]+,/.exec(resource);
 	if (!dataUrl) return resource;
 
@@ -55,11 +76,11 @@ const getResourceName = resource => {
 
 /**
  * @param {string} name module name
- * @returns {[string,string]} prefix and module name
+ * @returns {[string, string]} prefix and module name
  */
-const getModuleName = name => {
+const getModuleName = (name) => {
 	const [, prefix, resource] =
-		/** @type {[any, string, string]} */
+		/** @type {[string, string, string]} */
 		(/** @type {unknown} */ (/^(.*!)?([^!]*)$/.exec(name)));
 
 	if (resource.length > MAX_MODULE_IDENTIFIER_LENGTH) {
@@ -79,7 +100,7 @@ const getModuleName = name => {
 
 /**
  * @param {string} str string
- * @param {function(string): string} fn function to apply to each line
+ * @param {(item: string) => string} fn function to apply to each line
  * @returns {string} joined string
  */
 const mapLines = (str, fn) => str.split("\n").map(fn).join("\n");
@@ -88,17 +109,23 @@ const mapLines = (str, fn) => str.split("\n").map(fn).join("\n");
  * @param {number} n a number
  * @returns {string} number as two digit string, leading 0
  */
-const twoDigit = n => (n >= 10 ? `${n}` : `0${n}`);
+const twoDigit = (n) => (n >= 10 ? `${n}` : `0${n}`);
 
 /**
- * @param {string | number} id an id
- * @returns {boolean | string} is i
+ * @param {string | number | null} id an id
+ * @returns {id is string | number} is i
  */
-const isValidId = id => typeof id === "number" || id;
+const isValidId = (id) => {
+	if (typeof id === "number" || id) {
+		return true;
+	}
+
+	return false;
+};
 
 /**
  * @template T
- * @param {Array<T> | undefined} list of items
+ * @param {T[] | undefined} list of items
  * @param {number} count number of items to show
  * @returns {string} string representation of list
  */
@@ -111,7 +138,61 @@ const moreCount = (list, count) =>
  * @typedef {{ [P in K]-?: T[P] }} WithRequired
  */
 
-/** @type {Record<string, (thing: any, context: Required<KnownStatsPrinterColorFn> & Required<KnownStatsPrinterFormaters> & WithRequired<StatsPrinterContext, "type" | "compilation">, printer: StatsPrinter) => string | undefined>} */
+/**
+ * @template {keyof StatsPrinterContext} RequiredStatsPrinterContextKeys
+ * @typedef {StatsPrinterContextWithExtra & WithRequired<StatsPrinterContext, "compilation" | RequiredStatsPrinterContextKeys>} DefineStatsPrinterContext
+ */
+
+/**
+ * @template T
+ * @template {keyof StatsPrinterContext} RequiredStatsPrinterContextKeys
+ * @typedef {(thing: Exclude<T, undefined>, context: DefineStatsPrinterContext<RequiredStatsPrinterContextKeys>, printer: StatsPrinter) => string | undefined} SimplePrinter
+ */
+
+/**
+ * @template T
+ * @typedef {T extends (infer U)[] ? U : T} Unpacked
+ */
+
+/**
+ * @template {object} O
+ * @template {keyof O} K
+ * @template {string} B
+ * @typedef {K extends string ? `${B}.${K}` : never} PropertyName
+ */
+
+/**
+ * @template {object} O
+ * @template {keyof O} K
+ * @template {string} B
+ * @typedef {K extends string ? `${B}.${K}[]` : never} ArrayPropertyName
+ */
+
+/**
+ * @template {object} O
+ * @template {string} K
+ * @template {string} E
+ * @typedef {{ [property in `${K}!`]?: SimplePrinter<O, "compilation" | E> }} Exclamation
+ */
+
+/**
+ * @template {object} O
+ * @template {string} B
+ * @template {string} [R=B]
+ * @typedef {{ [K in keyof O as PropertyName<O, K, B>]?: SimplePrinter<O[K], R> } &
+ * { [K in keyof O as ArrayPropertyName<O, K, B>]?: Exclude<O[K], undefined> extends (infer I)[] ? SimplePrinter<I, R> : never }} Printers
+ */
+
+/**
+ * @typedef {Printers<KnownStatsCompilation, "compilation"> &
+ * { ["compilation.summary!"]?: SimplePrinter<KnownStatsCompilation, "compilation"> } &
+ * { ["compilation.errorsInChildren!"]?: SimplePrinter<KnownStatsCompilation, "compilation"> } &
+ * { ["compilation.warningsInChildren!"]?: SimplePrinter<KnownStatsCompilation, "compilation"> }} CompilationSimplePrinters
+ */
+
+/**
+ * @type {CompilationSimplePrinters}
+ */
 const COMPILATION_SIMPLE_PRINTERS = {
 	"compilation.summary!": (
 		_,
@@ -184,10 +265,11 @@ const COMPILATION_SIMPLE_PRINTERS = {
 			(errorsCount === 0 && warningsCount === 0) ||
 			timeMessage ||
 			hashMessage
-		)
+		) {
 			return `${builtAtMessage}${subjectMessage} ${statusMessage}${timeMessage}${hashMessage}`;
+		}
 	},
-	"compilation.filteredWarningDetailsCount": count =>
+	"compilation.filteredWarningDetailsCount": (count) =>
 		count
 			? `${count} ${plural(
 					count,
@@ -226,8 +308,12 @@ const COMPILATION_SIMPLE_PRINTERS = {
 			let chunkGroups = Object.values(namedChunkGroups);
 			if (entrypoints) {
 				chunkGroups = chunkGroups.filter(
-					group =>
-						!Object.prototype.hasOwnProperty.call(entrypoints, group.name)
+					(group) =>
+						!Object.prototype.hasOwnProperty.call(
+							entrypoints,
+							/** @type {string} */
+							(group.name)
+						)
 				);
 			}
 			return printer.print(context.type, chunkGroups, {
@@ -318,9 +404,19 @@ const COMPILATION_SIMPLE_PRINTERS = {
 	}
 };
 
-/** @type {Record<string, (thing: any, context: Required<KnownStatsPrinterColorFn> & Required<KnownStatsPrinterFormaters> & WithRequired<StatsPrinterContext, "type" | "compilation" | "asset">, printer: StatsPrinter) => string | undefined>} */
+/**
+ * @typedef {Printers<KnownStatsAsset, "asset"> &
+ * Printers<KnownStatsAsset["info"], "asset.info"> &
+ * Exclamation<KnownStatsAsset, "asset.separator", "asset"> &
+ * { ["asset.filteredChildren"]?: SimplePrinter<number, "asset"> } &
+ * { assetChunk?: SimplePrinter<ChunkId, "asset"> } &
+ * { assetChunkName?: SimplePrinter<ChunkName, "asset"> } &
+ * { assetChunkIdHint?: SimplePrinter<string, "asset"> }} AssetSimplePrinters
+ */
+
+/** @type {AssetSimplePrinters} */
 const ASSET_SIMPLE_PRINTERS = {
-	"asset.type": type => type,
+	"asset.type": (type) => type,
 	"asset.name": (name, { formatFilename, asset: { isOverSizeLimit } }) =>
 		formatFilename(name, isOverSizeLimit),
 	"asset.size": (size, { asset: { isOverSizeLimit }, yellow, formatSize }) =>
@@ -339,13 +435,7 @@ const ASSET_SIMPLE_PRINTERS = {
 	"asset.info.javascriptModule": (javascriptModule, { formatFlag }) =>
 		javascriptModule ? formatFlag("javascript module") : undefined,
 	"asset.info.sourceFilename": (sourceFilename, { formatFlag }) =>
-		sourceFilename
-			? formatFlag(
-					sourceFilename === true
-						? "from source file"
-						: `from: ${sourceFilename}`
-				)
-			: undefined,
+		sourceFilename ? formatFlag(`from: ${sourceFilename}`) : undefined,
 	"asset.info.development": (development, { green, formatFlag }) =>
 		development ? green(formatFlag("dev")) : undefined,
 	"asset.info.hotModuleReplacement": (
@@ -371,21 +461,27 @@ const ASSET_SIMPLE_PRINTERS = {
 			: undefined,
 
 	assetChunk: (id, { formatChunkId }) => formatChunkId(id),
-
-	assetChunkName: name => name,
-	assetChunkIdHint: name => name
+	assetChunkName: (name) => name || undefined,
+	assetChunkIdHint: (name) => name || undefined
 };
 
-/** @type {Record<string, (thing: any, context: Required<KnownStatsPrinterColorFn> & Required<KnownStatsPrinterFormaters> & WithRequired<StatsPrinterContext, "type" | "compilation" | "module">, printer: StatsPrinter) => string | undefined>} */
+/**
+ * @typedef {Printers<KnownStatsModule, "module"> &
+ * Exclamation<KnownStatsModule, "module.separator", "module"> &
+ * { ["module.filteredChildren"]?: SimplePrinter<number, "module"> } &
+ * { ["module.filteredReasons"]?: SimplePrinter<number, "module"> }} ModuleSimplePrinters
+ */
+
+/** @type {ModuleSimplePrinters} */
 const MODULE_SIMPLE_PRINTERS = {
-	"module.type": type => (type !== "module" ? type : undefined),
+	"module.type": (type) => (type !== "module" ? type : undefined),
 	"module.id": (id, { formatModuleId }) =>
 		isValidId(id) ? formatModuleId(id) : undefined,
 	"module.name": (name, { bold }) => {
 		const [prefix, resource] = getModuleName(name);
 		return `${prefix || ""}${bold(resource || "")}`;
 	},
-	"module.identifier": identifier => undefined,
+	"module.identifier": (_identifier) => undefined,
 	"module.layer": (layer, { formatLayer }) =>
 		layer ? formatLayer(layer) : undefined,
 	"module.sizes": printSizes,
@@ -396,8 +492,8 @@ const MODULE_SIMPLE_PRINTERS = {
 		cacheable === false ? red(formatFlag("not cacheable")) : undefined,
 	"module.orphan": (orphan, { formatFlag, yellow }) =>
 		orphan ? yellow(formatFlag("orphan")) : undefined,
-	"module.runtime": (runtime, { formatFlag, yellow }) =>
-		runtime ? yellow(formatFlag("runtime")) : undefined,
+	// "module.runtime": (runtime, { formatFlag, yellow }) =>
+	// 	runtime ? yellow(formatFlag("runtime")) : undefined,
 	"module.optional": (optional, { formatFlag, yellow }) =>
 		optional ? yellow(formatFlag("optional")) : undefined,
 	"module.dependent": (dependent, { formatFlag, cyan }) =>
@@ -419,19 +515,15 @@ const MODULE_SIMPLE_PRINTERS = {
 				)
 			: undefined,
 	"module.warnings": (warnings, { formatFlag, yellow }) =>
-		warnings === true
-			? yellow(formatFlag("warnings"))
-			: warnings
-				? yellow(
-						formatFlag(`${warnings} ${plural(warnings, "warning", "warnings")}`)
-					)
-				: undefined,
+		warnings
+			? yellow(
+					formatFlag(`${warnings} ${plural(warnings, "warning", "warnings")}`)
+				)
+			: undefined,
 	"module.errors": (errors, { formatFlag, red }) =>
-		errors === true
-			? red(formatFlag("errors"))
-			: errors
-				? red(formatFlag(`${errors} ${plural(errors, "error", "errors")}`))
-				: undefined,
+		errors
+			? red(formatFlag(`${errors} ${plural(errors, "error", "errors")}`))
+			: undefined,
 	"module.providedExports": (providedExports, { formatFlag, cyan }) => {
 		if (Array.isArray(providedExports)) {
 			if (providedExports.length === 0) return cyan(formatFlag("no exports"));
@@ -443,8 +535,9 @@ const MODULE_SIMPLE_PRINTERS = {
 			if (usedExports === null) return cyan(formatFlag("used exports unknown"));
 			if (usedExports === false) return cyan(formatFlag("module unused"));
 			if (Array.isArray(usedExports)) {
-				if (usedExports.length === 0)
+				if (usedExports.length === 0) {
 					return cyan(formatFlag("no exports used"));
+				}
 				const providedExportsCount = Array.isArray(module.providedExports)
 					? module.providedExports.length
 					: null;
@@ -465,7 +558,7 @@ const MODULE_SIMPLE_PRINTERS = {
 		yellow(optimizationBailout),
 	"module.issuerPath": (issuerPath, { module }) =>
 		module.profile ? undefined : "",
-	"module.profile": profile => undefined,
+	"module.profile": (_profile) => undefined,
 	"module.filteredModules": (filteredModules, { module: { modules } }) =>
 		filteredModules > 0
 			? `${moreCount(modules, filteredModules)} nested ${plural(
@@ -493,25 +586,38 @@ const MODULE_SIMPLE_PRINTERS = {
 	"module.separator!": () => "\n"
 };
 
-/** @type {Record<string, (thing: any, context: Required<KnownStatsPrinterColorFn> & Required<KnownStatsPrinterFormaters> & WithRequired<StatsPrinterContext, "type" | "compilation" | "moduleIssuer">, printer: StatsPrinter) => string | undefined>} */
+/**
+ * @typedef {Printers<KnownStatsModuleIssuer, "moduleIssuer"> &
+ * Printers<KnownStatsModuleIssuer["profile"], "moduleIssuer.profile", "moduleIssuer">} ModuleIssuerPrinters
+ */
+
+/** @type {ModuleIssuerPrinters} */
 const MODULE_ISSUER_PRINTERS = {
 	"moduleIssuer.id": (id, { formatModuleId }) => formatModuleId(id),
 	"moduleIssuer.profile.total": (value, { formatTime }) => formatTime(value)
 };
 
-/** @type {Record<string, (thing: any, context: Required<KnownStatsPrinterColorFn> & Required<KnownStatsPrinterFormaters> & WithRequired<StatsPrinterContext, "type" | "compilation" | "moduleReason">, printer: StatsPrinter) => string | undefined>} */
+/**
+ * @typedef {Printers<KnownStatsModuleReason, "moduleReason"> &
+ * { ["moduleReason.filteredChildren"]?: SimplePrinter<number, "moduleReason"> }} ModuleReasonsPrinters
+ */
+
+/** @type {ModuleReasonsPrinters} */
 const MODULE_REASON_PRINTERS = {
-	"moduleReason.type": type => type,
+	"moduleReason.type": (type) => type || undefined,
 	"moduleReason.userRequest": (userRequest, { cyan }) =>
 		cyan(getResourceName(userRequest)),
 	"moduleReason.moduleId": (moduleId, { formatModuleId }) =>
 		isValidId(moduleId) ? formatModuleId(moduleId) : undefined,
-	"moduleReason.module": (module, { magenta }) => magenta(module),
-	"moduleReason.loc": loc => loc,
-	"moduleReason.explanation": (explanation, { cyan }) => cyan(explanation),
+	"moduleReason.module": (module, { magenta }) =>
+		module ? magenta(module) : undefined,
+	"moduleReason.loc": (loc) => loc || undefined,
+	"moduleReason.explanation": (explanation, { cyan }) =>
+		explanation ? cyan(explanation) : undefined,
 	"moduleReason.active": (active, { formatFlag }) =>
 		active ? undefined : formatFlag("inactive"),
-	"moduleReason.resolvedModule": (module, { magenta }) => magenta(module),
+	"moduleReason.resolvedModule": (module, { magenta }) =>
+		module ? magenta(module) : undefined,
 	"moduleReason.filteredChildren": (
 		filteredChildren,
 		{ moduleReason: { children } }
@@ -525,7 +631,9 @@ const MODULE_REASON_PRINTERS = {
 			: undefined
 };
 
-/** @type {Record<string, (thing: any, context: Required<KnownStatsPrinterColorFn> & Required<KnownStatsPrinterFormaters> & WithRequired<StatsPrinterContext, "type" | "compilation" | "profile">, printer: StatsPrinter) => string | undefined>} */
+/** @typedef {Printers<KnownStatsProfile, "module.profile", "profile">} ModuleProfilePrinters */
+
+/** @type {ModuleProfilePrinters} */
 const MODULE_PROFILE_PRINTERS = {
 	"module.profile.total": (value, { formatTime }) => formatTime(value),
 	"module.profile.resolving": (value, { formatTime }) =>
@@ -544,11 +652,23 @@ const MODULE_PROFILE_PRINTERS = {
 		value ? `additional integration: ${formatTime(value)}` : undefined
 };
 
-/** @type {Record<string, (thing: any, context: Required<KnownStatsPrinterColorFn> & Required<KnownStatsPrinterFormaters> & WithRequired<StatsPrinterContext, "type" | "compilation" | "chunkGroupKind" | "chunkGroup">, printer: StatsPrinter) => string | undefined>} */
+/**
+ * @typedef {Exclamation<KnownStatsChunkGroup, "chunkGroup.kind", "chunkGroupKind"> &
+ * Exclamation<KnownStatsChunkGroup, "chunkGroup.separator", "chunkGroup"> &
+ * Printers<KnownStatsChunkGroup, "chunkGroup"> &
+ * Exclamation<KnownStatsChunkGroup, "chunkGroup.is", "chunkGroup"> &
+ * Printers<Exclude<KnownStatsChunkGroup["assets"], undefined>[number], "chunkGroupAsset" | "chunkGroup"> &
+ * { ['chunkGroupChildGroup.type']?: SimplePrinter<string, "chunkGroupAsset"> } &
+ * { ['chunkGroupChild.assets[]']?: SimplePrinter<string, "chunkGroupAsset"> } &
+ * { ['chunkGroupChild.chunks[]']?: SimplePrinter<ChunkId, "chunkGroupAsset"> } &
+ * { ['chunkGroupChild.name']?: SimplePrinter<ChunkName, "chunkGroupAsset"> }} ChunkGroupPrinters
+ */
+
+/** @type {ChunkGroupPrinters} */
 const CHUNK_GROUP_PRINTERS = {
 	"chunkGroup.kind!": (_, { chunkGroupKind }) => chunkGroupKind,
 	"chunkGroup.separator!": () => "\n",
-	"chunkGroup.name": (name, { bold }) => bold(name),
+	"chunkGroup.name": (name, { bold }) => (name ? bold(name) : undefined),
 	"chunkGroup.isOverSizeLimit": (isOverSizeLimit, { formatFlag, yellow }) =>
 		isOverSizeLimit ? yellow(formatFlag("big")) : undefined,
 	"chunkGroup.assetsSize": (size, { formatSize }) =>
@@ -583,26 +703,34 @@ const CHUNK_GROUP_PRINTERS = {
 			? undefined
 			: printer.print(
 					context.type,
-					Object.keys(children).map(key => ({
+					Object.keys(children).map((key) => ({
 						type: key,
 						children: children[key]
 					})),
 					context
 				),
-	"chunkGroupChildGroup.type": type => `${type}:`,
+	"chunkGroupChildGroup.type": (type) => `${type}:`,
 	"chunkGroupChild.assets[]": (file, { formatFilename }) =>
 		formatFilename(file),
 	"chunkGroupChild.chunks[]": (id, { formatChunkId }) => formatChunkId(id),
-	"chunkGroupChild.name": name => (name ? `(name: ${name})` : undefined)
+	"chunkGroupChild.name": (name) => (name ? `(name: ${name})` : undefined)
 };
 
-/** @type {Record<string, (thing: any, context: Required<KnownStatsPrinterColorFn> & Required<KnownStatsPrinterFormaters> & WithRequired<StatsPrinterContext, "type" | "compilation" | "chunk">, printer: StatsPrinter) => string | undefined>} */
+/**
+ * @typedef {Printers<KnownStatsChunk, "chunk"> &
+ * { ["chunk.childrenByOrder[].type"]: SimplePrinter<string, "chunk"> } &
+ * { ["chunk.childrenByOrder[].children[]"]: SimplePrinter<ChunkId, "chunk"> } &
+ * Exclamation<KnownStatsChunk, "chunk.separator", "chunk"> &
+ * Printers<KnownStatsChunkOrigin, "chunkOrigin">} ChunkPrinters
+ */
+
+/** @type {ChunkPrinters} */
 const CHUNK_PRINTERS = {
 	"chunk.id": (id, { formatChunkId }) => formatChunkId(id),
 	"chunk.files[]": (file, { formatFilename }) => formatFilename(file),
-	"chunk.names[]": name => name,
-	"chunk.idHints[]": name => name,
-	"chunk.runtime[]": name => name,
+	"chunk.names[]": (name) => name,
+	"chunk.idHints[]": (name) => name,
+	"chunk.runtime[]": (name) => name,
 	"chunk.sizes": (sizes, context) => printSizes(sizes, context),
 	"chunk.parents[]": (parents, context) =>
 		context.formatChunkId(parents, "parent"),
@@ -615,13 +743,13 @@ const CHUNK_PRINTERS = {
 			? undefined
 			: printer.print(
 					context.type,
-					Object.keys(childrenByOrder).map(key => ({
+					Object.keys(childrenByOrder).map((key) => ({
 						type: key,
 						children: childrenByOrder[key]
 					})),
 					context
 				),
-	"chunk.childrenByOrder[].type": type => `${type}:`,
+	"chunk.childrenByOrder[].type": (type) => `${type}:`,
 	"chunk.childrenByOrder[].children[]": (id, { formatChunkId }) =>
 		isValidId(id) ? formatChunkId(id) : undefined,
 	"chunk.entry": (entry, { formatFlag, yellow }) =>
@@ -643,14 +771,22 @@ const CHUNK_PRINTERS = {
 			: undefined,
 	"chunk.separator!": () => "\n",
 
-	"chunkOrigin.request": request => request,
+	"chunkOrigin.request": (request) => request,
 	"chunkOrigin.moduleId": (moduleId, { formatModuleId }) =>
 		isValidId(moduleId) ? formatModuleId(moduleId) : undefined,
 	"chunkOrigin.moduleName": (moduleName, { bold }) => bold(moduleName),
-	"chunkOrigin.loc": loc => loc
+	"chunkOrigin.loc": (loc) => loc
 };
 
-/** @type {Record<string, (thing: any, context: Required<KnownStatsPrinterColorFn> & Required<KnownStatsPrinterFormaters> & WithRequired<StatsPrinterContext, "type" | "compilation" | "error">, printer: StatsPrinter) => string | undefined>} */
+/**
+ * @typedef {Printers<KnownStatsError, "error"> &
+ * { ["error.filteredDetails"]?: SimplePrinter<number, "error"> } &
+ * Exclamation<KnownStatsError, "error.separator", "error">} ErrorPrinters
+ */
+
+/**
+ * @type {ErrorPrinters}
+ */
 const ERROR_PRINTERS = {
 	"error.compilerPath": (compilerPath, { bold }) =>
 		compilerPath ? bold(`(${compilerPath})`) : undefined,
@@ -669,64 +805,89 @@ const ERROR_PRINTERS = {
 	"error.message": (message, { bold, formatError }) =>
 		message.includes("\u001B[") ? message : bold(formatError(message)),
 	"error.details": (details, { formatError }) => formatError(details),
-	"error.filteredDetails": filteredDetails =>
+	"error.filteredDetails": (filteredDetails) =>
 		filteredDetails ? `+ ${filteredDetails} hidden lines` : undefined,
-	"error.stack": stack => stack,
-	"error.moduleTrace": moduleTrace => undefined,
+	"error.stack": (stack) => stack,
+	"error.cause": (cause, context, printer) =>
+		cause
+			? indent(
+					`[cause]: ${
+						/** @type {string} */
+						(printer.print(`${context.type}.error`, cause, context))
+					}`,
+					"  "
+				)
+			: undefined,
+	"error.moduleTrace": (_moduleTrace) => undefined,
 	"error.separator!": () => "\n"
 };
 
-/** @type {Record<string, (thing: any, context: Required<KnownStatsPrinterColorFn> & Required<KnownStatsPrinterFormaters> & WithRequired<StatsPrinterContext, "type" | "compilation" | "logging">, printer: StatsPrinter) => string | undefined>} */
+/**
+ * @typedef {Printers<KnownStatsLoggingEntry, `loggingEntry(${LogTypeEnum}).loggingEntry`> &
+ * { ["loggingEntry(clear).loggingEntry"]?: SimplePrinter<KnownStatsLoggingEntry, "logging"> } &
+ * { ["loggingEntry.trace[]"]?: SimplePrinter<Exclude<KnownStatsLoggingEntry["trace"], undefined>[number], "logging"> } &
+ * { loggingGroup?: SimplePrinter<KnownStatsLogging[], "logging"> } &
+ * Printers<KnownStatsLogging & { name: string }, `loggingGroup`> &
+ * Exclamation<KnownStatsLogging, "loggingGroup.separator", "loggingGroup">} LogEntryPrinters
+ */
+
+/** @type {LogEntryPrinters} */
 const LOG_ENTRY_PRINTERS = {
 	"loggingEntry(error).loggingEntry.message": (message, { red }) =>
-		mapLines(message, x => `<e> ${red(x)}`),
+		mapLines(message, (x) => `<e> ${red(x)}`),
 	"loggingEntry(warn).loggingEntry.message": (message, { yellow }) =>
-		mapLines(message, x => `<w> ${yellow(x)}`),
+		mapLines(message, (x) => `<w> ${yellow(x)}`),
 	"loggingEntry(info).loggingEntry.message": (message, { green }) =>
-		mapLines(message, x => `<i> ${green(x)}`),
+		mapLines(message, (x) => `<i> ${green(x)}`),
 	"loggingEntry(log).loggingEntry.message": (message, { bold }) =>
-		mapLines(message, x => `    ${bold(x)}`),
-	"loggingEntry(debug).loggingEntry.message": message =>
-		mapLines(message, x => `    ${x}`),
-	"loggingEntry(trace).loggingEntry.message": message =>
-		mapLines(message, x => `    ${x}`),
+		mapLines(message, (x) => `    ${bold(x)}`),
+	"loggingEntry(debug).loggingEntry.message": (message) =>
+		mapLines(message, (x) => `    ${x}`),
+	"loggingEntry(trace).loggingEntry.message": (message) =>
+		mapLines(message, (x) => `    ${x}`),
 	"loggingEntry(status).loggingEntry.message": (message, { magenta }) =>
-		mapLines(message, x => `<s> ${magenta(x)}`),
+		mapLines(message, (x) => `<s> ${magenta(x)}`),
 	"loggingEntry(profile).loggingEntry.message": (message, { magenta }) =>
-		mapLines(message, x => `<p> ${magenta(x)}`),
+		mapLines(message, (x) => `<p> ${magenta(x)}`),
 	"loggingEntry(profileEnd).loggingEntry.message": (message, { magenta }) =>
-		mapLines(message, x => `</p> ${magenta(x)}`),
+		mapLines(message, (x) => `</p> ${magenta(x)}`),
 	"loggingEntry(time).loggingEntry.message": (message, { magenta }) =>
-		mapLines(message, x => `<t> ${magenta(x)}`),
+		mapLines(message, (x) => `<t> ${magenta(x)}`),
 	"loggingEntry(group).loggingEntry.message": (message, { cyan }) =>
-		mapLines(message, x => `<-> ${cyan(x)}`),
+		mapLines(message, (x) => `<-> ${cyan(x)}`),
 	"loggingEntry(groupCollapsed).loggingEntry.message": (message, { cyan }) =>
-		mapLines(message, x => `<+> ${cyan(x)}`),
+		mapLines(message, (x) => `<+> ${cyan(x)}`),
 	"loggingEntry(clear).loggingEntry": () => "    -------",
 	"loggingEntry(groupCollapsed).loggingEntry.children": () => "",
-	"loggingEntry.trace[]": trace =>
-		trace ? mapLines(trace, x => `| ${x}`) : undefined,
+	"loggingEntry.trace[]": (trace) =>
+		trace ? mapLines(trace, (x) => `| ${x}`) : undefined,
 
-	loggingGroup: loggingGroup =>
+	loggingGroup: (loggingGroup) =>
 		loggingGroup.entries.length === 0 ? "" : undefined,
 	"loggingGroup.debug": (flag, { red }) => (flag ? red("DEBUG") : undefined),
 	"loggingGroup.name": (name, { bold }) => bold(`LOG from ${name}`),
 	"loggingGroup.separator!": () => "\n",
-	"loggingGroup.filteredEntries": filteredEntries =>
+	"loggingGroup.filteredEntries": (filteredEntries) =>
 		filteredEntries > 0 ? `+ ${filteredEntries} hidden lines` : undefined
 };
 
-/** @type {Record<string, (thing: any, context: Required<KnownStatsPrinterColorFn> & Required<KnownStatsPrinterFormaters> & WithRequired<StatsPrinterContext, "type" | "compilation" | "moduleTraceItem">, printer: StatsPrinter) => string | undefined>} */
+/** @typedef {Printers<KnownStatsModuleTraceItem, "moduleTraceItem">} ModuleTraceItemPrinters */
+
+/** @type {ModuleTraceItemPrinters} */
 const MODULE_TRACE_ITEM_PRINTERS = {
-	"moduleTraceItem.originName": originName => originName
+	"moduleTraceItem.originName": (originName) => originName
 };
 
-/** @type {Record<string, (thing: any, context: Required<KnownStatsPrinterColorFn> & Required<KnownStatsPrinterFormaters> & WithRequired<StatsPrinterContext, "type" | "compilation" | "moduleTraceDependency">, printer: StatsPrinter) => string | undefined>} */
+/** @typedef {Printers<KnownStatsModuleTraceDependency, "moduleTraceDependency">} ModuleTraceDependencyPrinters */
+
+/** @type {ModuleTraceDependencyPrinters} */
 const MODULE_TRACE_DEPENDENCY_PRINTERS = {
-	"moduleTraceDependency.loc": loc => loc
+	"moduleTraceDependency.loc": (loc) => loc
 };
 
-/** @type {Record<string, string | function(any): string>} */
+/**
+ * @type {Record<string, string | ((item: KnownStatsLoggingEntry) => string)>}
+ */
 const ITEM_NAMES = {
 	"compilation.assets[]": "asset",
 	"compilation.modules[]": "module",
@@ -758,11 +919,12 @@ const ITEM_NAMES = {
 	"module.issuerPath[]": "moduleIssuer",
 	"chunk.origins[]": "chunkOrigin",
 	"chunk.modules[]": "module",
-	"loggingGroup.entries[]": logEntry =>
+	"loggingGroup.entries[]": (logEntry) =>
 		`loggingEntry(${logEntry.type}).loggingEntry`,
-	"loggingEntry.children[]": logEntry =>
+	"loggingEntry.children[]": (logEntry) =>
 		`loggingEntry(${logEntry.type}).loggingEntry`,
 	"error.moduleTrace[]": "moduleTraceItem",
+	"error.errors[]": "error",
 	"moduleTraceItem.dependencies[]": "moduleTraceDependency"
 };
 
@@ -784,6 +946,8 @@ const ERROR_PREFERRED_ORDER = [
 	"separator!",
 	"stack",
 	"separator!",
+	"cause",
+	"separator!",
 	"missing",
 	"separator!",
 	"moduleTrace"
@@ -958,19 +1122,19 @@ const PREFERRED_ORDERS = {
 /** @typedef {(items: string[]) => string | undefined} SimpleItemsJoiner */
 
 /** @type {SimpleItemsJoiner} */
-const itemsJoinOneLine = items => items.filter(Boolean).join(" ");
+const itemsJoinOneLine = (items) => items.filter(Boolean).join(" ");
 /** @type {SimpleItemsJoiner} */
-const itemsJoinOneLineBrackets = items =>
+const itemsJoinOneLineBrackets = (items) =>
 	items.length > 0 ? `(${items.filter(Boolean).join(" ")})` : undefined;
 /** @type {SimpleItemsJoiner} */
-const itemsJoinMoreSpacing = items => items.filter(Boolean).join("\n\n");
+const itemsJoinMoreSpacing = (items) => items.filter(Boolean).join("\n\n");
 /** @type {SimpleItemsJoiner} */
-const itemsJoinComma = items => items.filter(Boolean).join(", ");
+const itemsJoinComma = (items) => items.filter(Boolean).join(", ");
 /** @type {SimpleItemsJoiner} */
-const itemsJoinCommaBrackets = items =>
+const itemsJoinCommaBrackets = (items) =>
 	items.length > 0 ? `(${items.filter(Boolean).join(", ")})` : undefined;
-/** @type {function(string): SimpleItemsJoiner} */
-const itemsJoinCommaBracketsWithName = name => items =>
+/** @type {(item: string) => SimpleItemsJoiner} */
+const itemsJoinCommaBracketsWithName = (name) => (items) =>
 	items.length > 0
 		? `(${name}: ${items.filter(Boolean).join(", ")})`
 		: undefined;
@@ -999,18 +1163,18 @@ const SIMPLE_ITEMS_JOINER = {
 	"asset.auxiliaryChunkIdHints":
 		itemsJoinCommaBracketsWithName("auxiliary id hint"),
 	"module.chunks": itemsJoinOneLine,
-	"module.issuerPath": items =>
+	"module.issuerPath": (items) =>
 		items
 			.filter(Boolean)
-			.map(item => `${item} ->`)
+			.map((item) => `${item} ->`)
 			.join(" "),
 	"compilation.errors": itemsJoinMoreSpacing,
 	"compilation.warnings": itemsJoinMoreSpacing,
 	"compilation.logging": itemsJoinMoreSpacing,
-	"compilation.children": items =>
+	"compilation.children": (items) =>
 		indent(/** @type {string} */ (itemsJoinMoreSpacing(items)), "  "),
 	"moduleTraceItem.dependencies": itemsJoinOneLine,
-	"loggingEntry.children": items =>
+	"loggingEntry.children": (items) =>
 		indent(items.filter(Boolean).join("\n"), "  ", false)
 };
 
@@ -1018,9 +1182,9 @@ const SIMPLE_ITEMS_JOINER = {
  * @param {Item[]} items items
  * @returns {string} result
  */
-const joinOneLine = items =>
+const joinOneLine = (items) =>
 	items
-		.map(item => item.content)
+		.map((item) => item.content)
 		.filter(Boolean)
 		.join(" ");
 
@@ -1028,7 +1192,7 @@ const joinOneLine = items =>
  * @param {Item[]} items items
  * @returns {string} result
  */
-const joinInBrackets = items => {
+const joinInBrackets = (items) => {
 	const res = [];
 	let mode = 0;
 	for (const item of items) {
@@ -1092,7 +1256,7 @@ const joinExplicitNewLine = (items, indenter) => {
 	let firstInLine = true;
 	let first = true;
 	return items
-		.map(item => {
+		.map((item) => {
 			if (!item || !item.content) return;
 			let content = indent(item.content, first ? "" : indenter, !firstInLine);
 			if (firstInLine) {
@@ -1114,10 +1278,10 @@ const joinExplicitNewLine = (items, indenter) => {
  * @returns {SimpleElementJoiner} joiner
  */
 const joinError =
-	error =>
+	(error) =>
 	/**
 	 * @param {Item[]} items items
-	 * @param {Required<StatsPrinterContext>} ctx context
+	 * @param {StatsPrinterContextWithExtra} ctx context
 	 * @returns {string} result
 	 */
 	(items, { red, yellow }) =>
@@ -1126,12 +1290,12 @@ const joinError =
 			""
 		)}`;
 
-/** @typedef {{ element: string, content: string }} Item */
-/** @typedef {(items: Item[], context: Required<StatsPrinterContext>) => string} SimpleElementJoiner */
+/** @typedef {{ element: string, content: string | undefined }} Item */
+/** @typedef {(items: Item[], context: StatsPrinterContextWithExtra & Required<KnownStatsPrinterContext>) => string} SimpleElementJoiner */
 
 /** @type {Record<string, SimpleElementJoiner>} */
 const SIMPLE_ELEMENT_JOINERS = {
-	compilation: items => {
+	compilation: (items) => {
 		const result = [];
 		let lastNeedMore = false;
 		for (const item of items) {
@@ -1151,9 +1315,9 @@ const SIMPLE_ELEMENT_JOINERS = {
 		if (lastNeedMore) result.push("\n");
 		return result.join("");
 	},
-	asset: items =>
+	asset: (items) =>
 		joinExplicitNewLine(
-			items.map(item => {
+			items.map((item) => {
 				if (
 					(item.element === "related" || item.element === "children") &&
 					item.content
@@ -1171,7 +1335,7 @@ const SIMPLE_ELEMENT_JOINERS = {
 	module: (items, { module }) => {
 		let hasName = false;
 		return joinExplicitNewLine(
-			items.map(item => {
+			items.map((item) => {
 				switch (item.element) {
 					case "id":
 						if (module.id === module.name) {
@@ -1204,10 +1368,10 @@ const SIMPLE_ELEMENT_JOINERS = {
 			"  "
 		);
 	},
-	chunk: items => {
+	chunk: (items) => {
 		let hasEntry = false;
 		return `chunk ${joinExplicitNewLine(
-			items.filter(item => {
+			items.filter((item) => {
 				switch (item.element) {
 					case "entry":
 						if (item.content) hasEntry = true;
@@ -1221,48 +1385,28 @@ const SIMPLE_ELEMENT_JOINERS = {
 			"  "
 		)}`;
 	},
-	"chunk.childrenByOrder[]": items => `(${joinOneLine(items)})`,
-	chunkGroup: items => joinExplicitNewLine(items, "  "),
+	"chunk.childrenByOrder[]": (items) => `(${joinOneLine(items)})`,
+	chunkGroup: (items) => joinExplicitNewLine(items, "  "),
 	chunkGroupAsset: joinOneLine,
 	chunkGroupChildGroup: joinOneLine,
 	chunkGroupChild: joinOneLine,
-	// moduleReason: (items, { moduleReason }) => {
-	// 	let hasName = false;
-	// 	return joinOneLine(
-	// 		items.filter(item => {
-	// 			switch (item.element) {
-	// 				case "moduleId":
-	// 					if (moduleReason.moduleId === moduleReason.module && item.content)
-	// 						hasName = true;
-	// 					break;
-	// 				case "module":
-	// 					if (hasName) return false;
-	// 					break;
-	// 				case "resolvedModule":
-	// 					return (
-	// 						moduleReason.module !== moduleReason.resolvedModule &&
-	// 						item.content
-	// 					);
-	// 			}
-	// 			return true;
-	// 		})
-	// 	);
-	// },
 	moduleReason: (items, { moduleReason }) => {
 		let hasName = false;
 		return joinExplicitNewLine(
-			items.map(item => {
+			items.map((item) => {
 				switch (item.element) {
 					case "moduleId":
-						if (moduleReason.moduleId === moduleReason.module && item.content)
+						if (moduleReason.moduleId === moduleReason.module && item.content) {
 							hasName = true;
+						}
 						break;
 					case "module":
 						if (hasName) return false;
 						break;
 					case "resolvedModule":
-						if (moduleReason.module === moduleReason.resolvedModule)
+						if (moduleReason.module === moduleReason.resolvedModule) {
 							return false;
+						}
 						break;
 					case "children":
 						if (item.content) {
@@ -1280,17 +1424,18 @@ const SIMPLE_ELEMENT_JOINERS = {
 	},
 	"module.profile": joinInBrackets,
 	moduleIssuer: joinOneLine,
-	chunkOrigin: items => `> ${joinOneLine(items)}`,
+	chunkOrigin: (items) => `> ${joinOneLine(items)}`,
 	"errors[].error": joinError(true),
 	"warnings[].error": joinError(false),
-	loggingGroup: items => joinExplicitNewLine(items, "").trimEnd(),
-	moduleTraceItem: items => ` @ ${joinOneLine(items)}`,
+	error: (items) => joinExplicitNewLine(items, ""),
+	"error.errors[].error": (items) =>
+		indent(`[errors]: ${joinExplicitNewLine(items, "")}`, "  "),
+	loggingGroup: (items) => joinExplicitNewLine(items, "").trimEnd(),
+	moduleTraceItem: (items) => ` @ ${joinOneLine(items)}`,
 	moduleTraceDependency: joinOneLine
 };
 
-/** @typedef {"bold" | "yellow" | "red" | "green" | "cyan" | "magenta"} ColorNames */
-
-/** @type {Record<ColorNames, string>} */
+/** @type {Record<keyof KnownStatsPrinterColorFunctions, string>} */
 const AVAILABLE_COLORS = {
 	bold: "\u001B[1m",
 	yellow: "\u001B[1m\u001B[33m",
@@ -1300,7 +1445,19 @@ const AVAILABLE_COLORS = {
 	magenta: "\u001B[1m\u001B[35m"
 };
 
-/** @type {Record<string, function(any, Required<KnownStatsPrinterColorFn> & StatsPrinterContext, ...any): string>} */
+/**
+ * @template T
+ * @typedef {T extends [infer Head, ...infer Tail] ? Tail : undefined} Tail
+ */
+
+/**
+ * @template {(...args: EXPECTED_ANY[]) => EXPECTED_ANY} T
+ * @typedef {T extends (firstArg: EXPECTED_ANY, ...rest: infer R) => EXPECTED_ANY ? R : never} TailParameters
+ */
+
+/** @typedef {{ [Key in keyof KnownStatsPrinterFormatters]: (value: Parameters<NonNullable<KnownStatsPrinterFormatters[Key]>>[0], options: Required<KnownStatsPrinterColorFunctions> & StatsPrinterContextWithExtra, ...args: TailParameters<NonNullable<KnownStatsPrinterFormatters[Key]>>) => string }} AvailableFormats */
+
+/** @type {AvailableFormats} */
 const AVAILABLE_FORMATS = {
 	formatChunkId: (id, { yellow }, direction) => {
 		switch (direction) {
@@ -1314,11 +1471,11 @@ const AVAILABLE_FORMATS = {
 				return `{${yellow(id)}}`;
 		}
 	},
-	formatModuleId: id => `[${id}]`,
+	formatModuleId: (id) => `[${id}]`,
 	formatFilename: (filename, { green, yellow }, oversize) =>
 		(oversize ? yellow : green)(filename),
-	formatFlag: flag => `[${flag}]`,
-	formatLayer: layer => `(in ${layer})`,
+	formatFlag: (flag) => `[${flag}]`,
+	formatLayer: (layer) => `(in ${layer})`,
 	formatSize: require("../SizeFormatHelpers").formatSize,
 	formatDateTime: (dateTime, { bold }) => {
 		const d = new Date(dateTime);
@@ -1391,10 +1548,10 @@ const AVAILABLE_FORMATS = {
 	}
 };
 
-/** @typedef {function(string): string} ResultModifierFn */
+/** @typedef {(result: string) => string} ResultModifierFn */
 /** @type {Record<string, ResultModifierFn>} */
 const RESULT_MODIFIER = {
-	"module.modules": result => indent(result, "| ")
+	"module.modules": (result) => indent(result, "| ")
 };
 
 /**
@@ -1403,7 +1560,7 @@ const RESULT_MODIFIER = {
  * @returns {string[]} result
  */
 const createOrder = (array, preferredOrder) => {
-	const originalArray = array.slice();
+	const originalArray = [...array];
 	/** @type {Set<string>} */
 	const set = new Set(array);
 	/** @type {Set<string>} */
@@ -1423,6 +1580,8 @@ const createOrder = (array, preferredOrder) => {
 	return array;
 };
 
+const PLUGIN_NAME = "DefaultStatsPrinterPlugin";
+
 class DefaultStatsPrinterPlugin {
 	/**
 	 * Apply the plugin
@@ -1430,266 +1589,271 @@ class DefaultStatsPrinterPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap("DefaultStatsPrinterPlugin", compilation => {
-			compilation.hooks.statsPrinter.tap(
-				"DefaultStatsPrinterPlugin",
-				(stats, options) => {
-					// Put colors into context
-					stats.hooks.print
-						.for("compilation")
-						.tap("DefaultStatsPrinterPlugin", (compilation, context) => {
-							for (const color of Object.keys(AVAILABLE_COLORS)) {
-								const name = /** @type {ColorNames} */ (color);
-								/** @type {string | undefined} */
-								let start;
-								if (options.colors) {
-									if (
-										typeof options.colors === "object" &&
-										typeof options.colors[name] === "string"
-									) {
-										start = options.colors[name];
-									} else {
-										start = AVAILABLE_COLORS[name];
-									}
-								}
-								if (start) {
-									/**
-									 * @param {string} str string
-									 * @returns {string} string with color
-									 */
-									context[color] = str =>
-										`${start}${
-											typeof str === "string"
-												? str.replace(
-														/((\u001B\[39m|\u001B\[22m|\u001B\[0m)+)/g,
-														`$1${start}`
-													)
-												: str
-										}\u001B[39m\u001B[22m`;
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			compilation.hooks.statsPrinter.tap(PLUGIN_NAME, (stats, options) => {
+				// Put colors into context
+				stats.hooks.print
+					.for("compilation")
+					.tap(PLUGIN_NAME, (compilation, context) => {
+						for (const color of Object.keys(AVAILABLE_COLORS)) {
+							const name =
+								/** @type {keyof KnownStatsPrinterColorFunctions} */
+								(color);
+							/** @type {string | undefined} */
+							let start;
+							if (options.colors) {
+								if (
+									typeof options.colors === "object" &&
+									typeof options.colors[name] === "string"
+								) {
+									start = options.colors[name];
 								} else {
-									/**
-									 * @param {string} str string
-									 * @returns {string} str string
-									 */
-									context[color] = str => str;
+									start = AVAILABLE_COLORS[name];
 								}
 							}
-							for (const format of Object.keys(AVAILABLE_FORMATS)) {
-								context[format] =
-									/**
-									 * @param {string | number} content content
-									 * @param {...TODO} args args
-									 * @returns {string} result
-									 */
-									(content, ...args) =>
-										AVAILABLE_FORMATS[format](
-											content,
-											/** @type {Required<KnownStatsPrinterColorFn> & StatsPrinterContext} */
-											(context),
-											...args
-										);
+							if (start) {
+								/** @type {ColorFunction} */
+								context[color] = (str) =>
+									`${start}${
+										typeof str === "string"
+											? str.replace(
+													// eslint-disable-next-line no-control-regex
+													/((\u001B\[39m|\u001B\[22m|\u001B\[0m)+)/g,
+													`$1${start}`
+												)
+											: str
+									}\u001B[39m\u001B[22m`;
+							} else {
+								/**
+								 * @param {string} str string
+								 * @returns {string} str string
+								 */
+								context[color] = (str) => str;
 							}
-							context.timeReference = compilation.time;
+						}
+						for (const format of /** @type {(keyof KnownStatsPrinterFormatters)[]} */ (
+							Object.keys(AVAILABLE_FORMATS)
+						)) {
+							context[format] =
+								/** @type {(content: Parameters<NonNullable<KnownStatsPrinterFormatters[keyof KnownStatsPrinterFormatters]>>[0], ...args: Tail<Parameters<NonNullable<KnownStatsPrinterFormatters[keyof KnownStatsPrinterFormatters]>>>) => string} */
+								(content, ...args) =>
+									/** @type {EXPECTED_ANY} */
+									(AVAILABLE_FORMATS[format])(
+										content,
+										/** @type {StatsPrinterContext & Required<KnownStatsPrinterColorFunctions>} */
+										(context),
+										...args
+									);
+						}
+						context.timeReference = compilation.time;
+					});
+
+				for (const key of /** @type {(keyof CompilationSimplePrinters)[]} */ (
+					Object.keys(COMPILATION_SIMPLE_PRINTERS)
+				)) {
+					stats.hooks.print.for(key).tap(PLUGIN_NAME, (obj, ctx) =>
+						/** @type {EXPECTED_ANY} */
+						(COMPILATION_SIMPLE_PRINTERS)[key](
+							obj,
+							/** @type {DefineStatsPrinterContext<"compilation">} */
+							(ctx),
+							stats
+						)
+					);
+				}
+
+				for (const key of /** @type {(keyof AssetSimplePrinters)[]} */ (
+					Object.keys(ASSET_SIMPLE_PRINTERS)
+				)) {
+					stats.hooks.print.for(key).tap(PLUGIN_NAME, (obj, ctx) =>
+						/** @type {NonNullable<AssetSimplePrinters[keyof AssetSimplePrinters]>} */
+						(ASSET_SIMPLE_PRINTERS[key])(
+							obj,
+							/** @type {DefineStatsPrinterContext<"asset" | "asset.info">} */
+							(ctx),
+							stats
+						)
+					);
+				}
+
+				for (const key of /** @type {(keyof ModuleSimplePrinters)[]} */ (
+					Object.keys(MODULE_SIMPLE_PRINTERS)
+				)) {
+					stats.hooks.print.for(key).tap(PLUGIN_NAME, (obj, ctx) =>
+						/** @type {EXPECTED_ANY} */
+						(MODULE_SIMPLE_PRINTERS)[key](
+							obj,
+							/** @type {DefineStatsPrinterContext<"module">} */
+							(ctx),
+							stats
+						)
+					);
+				}
+
+				for (const key of /** @type {(keyof ModuleIssuerPrinters)[]} */ (
+					Object.keys(MODULE_ISSUER_PRINTERS)
+				)) {
+					stats.hooks.print.for(key).tap(PLUGIN_NAME, (obj, ctx) =>
+						/** @type {NonNullable<ModuleIssuerPrinters[keyof ModuleIssuerPrinters]>} */
+						(MODULE_ISSUER_PRINTERS[key])(
+							obj,
+							/** @type {DefineStatsPrinterContext<"moduleIssuer">} */
+							(ctx),
+							stats
+						)
+					);
+				}
+
+				for (const key of /** @type {(keyof ModuleReasonsPrinters)[]} */ (
+					Object.keys(MODULE_REASON_PRINTERS)
+				)) {
+					stats.hooks.print.for(key).tap(PLUGIN_NAME, (obj, ctx) =>
+						/** @type {EXPECTED_ANY} */
+						(MODULE_REASON_PRINTERS)[key](
+							obj,
+							/** @type {DefineStatsPrinterContext<"moduleReason">} */
+							(ctx),
+							stats
+						)
+					);
+				}
+
+				for (const key of /** @type {(keyof ModuleProfilePrinters)[]} */ (
+					Object.keys(MODULE_PROFILE_PRINTERS)
+				)) {
+					stats.hooks.print.for(key).tap(PLUGIN_NAME, (obj, ctx) =>
+						/** @type {NonNullable<ModuleProfilePrinters[keyof ModuleProfilePrinters]>} */
+						(MODULE_PROFILE_PRINTERS[key])(
+							obj,
+							/** @type {DefineStatsPrinterContext<"profile">} */
+							(ctx),
+							stats
+						)
+					);
+				}
+
+				for (const key of /** @type {(keyof ChunkGroupPrinters)[]} */ (
+					Object.keys(CHUNK_GROUP_PRINTERS)
+				)) {
+					stats.hooks.print.for(key).tap(PLUGIN_NAME, (obj, ctx) =>
+						/** @type {EXPECTED_ANY} */
+						(CHUNK_GROUP_PRINTERS)[key](
+							obj,
+							/** @type {DefineStatsPrinterContext<"chunkGroupKind" | "chunkGroup">} */
+							(ctx),
+							stats
+						)
+					);
+				}
+
+				for (const key of /** @type {(keyof ChunkPrinters)[]} */ (
+					Object.keys(CHUNK_PRINTERS)
+				)) {
+					stats.hooks.print.for(key).tap(PLUGIN_NAME, (obj, ctx) =>
+						/** @type {EXPECTED_ANY} */
+						(CHUNK_PRINTERS)[key](
+							obj,
+							/** @type {DefineStatsPrinterContext<"chunk">} */
+							(ctx),
+							stats
+						)
+					);
+				}
+
+				for (const key of /** @type {(keyof ErrorPrinters)[]} */ (
+					Object.keys(ERROR_PRINTERS)
+				)) {
+					stats.hooks.print.for(key).tap(PLUGIN_NAME, (obj, ctx) =>
+						/** @type {EXPECTED_ANY} */
+						(ERROR_PRINTERS)[key](
+							obj,
+							/** @type {DefineStatsPrinterContext<"error">} */
+							(ctx),
+							stats
+						)
+					);
+				}
+
+				for (const key of /** @type {(keyof LogEntryPrinters)[]} */ (
+					Object.keys(LOG_ENTRY_PRINTERS)
+				)) {
+					stats.hooks.print.for(key).tap(PLUGIN_NAME, (obj, ctx) =>
+						/** @type {EXPECTED_ANY} */
+						(LOG_ENTRY_PRINTERS)[key](
+							obj,
+							/** @type {DefineStatsPrinterContext<"logging">} */
+							(ctx),
+							stats
+						)
+					);
+				}
+
+				for (const key of /** @type {(keyof ModuleTraceDependencyPrinters)[]} */ (
+					Object.keys(MODULE_TRACE_DEPENDENCY_PRINTERS)
+				)) {
+					stats.hooks.print.for(key).tap(PLUGIN_NAME, (obj, ctx) =>
+						/** @type {NonNullable<ModuleTraceDependencyPrinters[keyof ModuleTraceDependencyPrinters]>} */
+						(MODULE_TRACE_DEPENDENCY_PRINTERS[key])(
+							obj,
+							/** @type {DefineStatsPrinterContext<"moduleTraceDependency">} */
+							(ctx),
+							stats
+						)
+					);
+				}
+
+				for (const key of /** @type {(keyof ModuleTraceItemPrinters)[]} */ (
+					Object.keys(MODULE_TRACE_ITEM_PRINTERS)
+				)) {
+					stats.hooks.print.for(key).tap(PLUGIN_NAME, (obj, ctx) =>
+						/** @type {NonNullable<ModuleTraceItemPrinters[keyof ModuleTraceItemPrinters]>} */
+						(MODULE_TRACE_ITEM_PRINTERS[key])(
+							obj,
+							/** @type {DefineStatsPrinterContext<"moduleTraceItem">} */
+							(ctx),
+							stats
+						)
+					);
+				}
+
+				for (const key of Object.keys(PREFERRED_ORDERS)) {
+					const preferredOrder = PREFERRED_ORDERS[key];
+					stats.hooks.sortElements
+						.for(key)
+						.tap(PLUGIN_NAME, (elements, _context) => {
+							createOrder(elements, preferredOrder);
 						});
+				}
 
-					for (const key of Object.keys(COMPILATION_SIMPLE_PRINTERS)) {
-						stats.hooks.print
-							.for(key)
-							.tap("DefaultStatsPrinterPlugin", (obj, ctx) =>
-								COMPILATION_SIMPLE_PRINTERS[key](
-									obj,
-									/** @type {Required<KnownStatsPrinterColorFn> & Required<KnownStatsPrinterFormaters> & WithRequired<StatsPrinterContext, "type" | "compilation">} */
-									(ctx),
-									stats
-								)
-							);
-					}
-
-					for (const key of Object.keys(ASSET_SIMPLE_PRINTERS)) {
-						stats.hooks.print
-							.for(key)
-							.tap("DefaultStatsPrinterPlugin", (obj, ctx) =>
-								ASSET_SIMPLE_PRINTERS[key](
-									obj,
-									/** @type {Required<KnownStatsPrinterColorFn> & Required<KnownStatsPrinterFormaters> & WithRequired<StatsPrinterContext, "type" | "compilation" | "asset">} */
-									(ctx),
-									stats
-								)
-							);
-					}
-
-					for (const key of Object.keys(MODULE_SIMPLE_PRINTERS)) {
-						stats.hooks.print
-							.for(key)
-							.tap("DefaultStatsPrinterPlugin", (obj, ctx) =>
-								MODULE_SIMPLE_PRINTERS[key](
-									obj,
-									/** @type {Required<KnownStatsPrinterColorFn> & Required<KnownStatsPrinterFormaters> & WithRequired<StatsPrinterContext, "type" | "compilation" | "module">} */
-									(ctx),
-									stats
-								)
-							);
-					}
-
-					for (const key of Object.keys(MODULE_ISSUER_PRINTERS)) {
-						stats.hooks.print
-							.for(key)
-							.tap("DefaultStatsPrinterPlugin", (obj, ctx) =>
-								MODULE_ISSUER_PRINTERS[key](
-									obj,
-									/** @type {Required<KnownStatsPrinterColorFn> & Required<KnownStatsPrinterFormaters> & WithRequired<StatsPrinterContext, "type" | "compilation" | "moduleIssuer">} */
-									(ctx),
-									stats
-								)
-							);
-					}
-
-					for (const key of Object.keys(MODULE_REASON_PRINTERS)) {
-						stats.hooks.print
-							.for(key)
-							.tap("DefaultStatsPrinterPlugin", (obj, ctx) =>
-								MODULE_REASON_PRINTERS[key](
-									obj,
-									/** @type {Required<KnownStatsPrinterColorFn> & Required<KnownStatsPrinterFormaters> & WithRequired<StatsPrinterContext, "type" | "compilation" | "moduleReason">} */
-									(ctx),
-									stats
-								)
-							);
-					}
-
-					for (const key of Object.keys(MODULE_PROFILE_PRINTERS)) {
-						stats.hooks.print
-							.for(key)
-							.tap("DefaultStatsPrinterPlugin", (obj, ctx) =>
-								MODULE_PROFILE_PRINTERS[key](
-									obj,
-									/** @type {Required<KnownStatsPrinterColorFn> & Required<KnownStatsPrinterFormaters> & WithRequired<StatsPrinterContext, "type" | "compilation" | "profile">} */
-									(ctx),
-									stats
-								)
-							);
-					}
-
-					for (const key of Object.keys(CHUNK_GROUP_PRINTERS)) {
-						stats.hooks.print
-							.for(key)
-							.tap("DefaultStatsPrinterPlugin", (obj, ctx) =>
-								CHUNK_GROUP_PRINTERS[key](
-									obj,
-									/** @type {Required<KnownStatsPrinterColorFn> & Required<KnownStatsPrinterFormaters> & WithRequired<StatsPrinterContext, "type" | "compilation" | "chunkGroupKind" | "chunkGroup">} */
-									(ctx),
-									stats
-								)
-							);
-					}
-
-					for (const key of Object.keys(CHUNK_PRINTERS)) {
-						stats.hooks.print
-							.for(key)
-							.tap("DefaultStatsPrinterPlugin", (obj, ctx) =>
-								CHUNK_PRINTERS[key](
-									obj,
-									/** @type {Required<KnownStatsPrinterColorFn> & Required<KnownStatsPrinterFormaters> & WithRequired<StatsPrinterContext, "type" | "compilation" | "chunk">} */
-									(ctx),
-									stats
-								)
-							);
-					}
-
-					for (const key of Object.keys(ERROR_PRINTERS)) {
-						stats.hooks.print
-							.for(key)
-							.tap("DefaultStatsPrinterPlugin", (obj, ctx) =>
-								ERROR_PRINTERS[key](
-									obj,
-									/** @type {Required<KnownStatsPrinterColorFn> & Required<KnownStatsPrinterFormaters> & WithRequired<StatsPrinterContext, "type" | "compilation" | "error">} */
-									(ctx),
-									stats
-								)
-							);
-					}
-
-					for (const key of Object.keys(LOG_ENTRY_PRINTERS)) {
-						stats.hooks.print
-							.for(key)
-							.tap("DefaultStatsPrinterPlugin", (obj, ctx) =>
-								LOG_ENTRY_PRINTERS[key](
-									obj,
-									/** @type {Required<KnownStatsPrinterColorFn> & Required<KnownStatsPrinterFormaters> & WithRequired<StatsPrinterContext, "type" | "compilation" | "logging">} */
-									(ctx),
-									stats
-								)
-							);
-					}
-
-					for (const key of Object.keys(MODULE_TRACE_DEPENDENCY_PRINTERS)) {
-						stats.hooks.print
-							.for(key)
-							.tap("DefaultStatsPrinterPlugin", (obj, ctx) =>
-								MODULE_TRACE_DEPENDENCY_PRINTERS[key](
-									obj,
-									/** @type {Required<KnownStatsPrinterColorFn> & Required<KnownStatsPrinterFormaters> & WithRequired<StatsPrinterContext, "type" | "compilation" | "moduleTraceDependency">} */
-									(ctx),
-									stats
-								)
-							);
-					}
-
-					for (const key of Object.keys(MODULE_TRACE_ITEM_PRINTERS)) {
-						stats.hooks.print
-							.for(key)
-							.tap("DefaultStatsPrinterPlugin", (obj, ctx) =>
-								MODULE_TRACE_ITEM_PRINTERS[key](
-									obj,
-									/** @type {Required<KnownStatsPrinterColorFn> & Required<KnownStatsPrinterFormaters> & WithRequired<StatsPrinterContext, "type" | "compilation" | "moduleTraceItem">} */
-									(ctx),
-									stats
-								)
-							);
-					}
-
-					for (const key of Object.keys(PREFERRED_ORDERS)) {
-						const preferredOrder = PREFERRED_ORDERS[key];
-						stats.hooks.sortElements
-							.for(key)
-							.tap("DefaultStatsPrinterPlugin", (elements, context) => {
-								createOrder(elements, preferredOrder);
-							});
-					}
-
-					for (const key of Object.keys(ITEM_NAMES)) {
-						const itemName = ITEM_NAMES[key];
-						stats.hooks.getItemName
-							.for(key)
-							.tap(
-								"DefaultStatsPrinterPlugin",
-								typeof itemName === "string" ? () => itemName : itemName
-							);
-					}
-
-					for (const key of Object.keys(SIMPLE_ITEMS_JOINER)) {
-						const joiner = SIMPLE_ITEMS_JOINER[key];
-						stats.hooks.printItems
-							.for(key)
-							.tap("DefaultStatsPrinterPlugin", joiner);
-					}
-
-					for (const key of Object.keys(SIMPLE_ELEMENT_JOINERS)) {
-						const joiner = SIMPLE_ELEMENT_JOINERS[key];
-						stats.hooks.printElements
-							.for(key)
-							.tap("DefaultStatsPrinterPlugin", /** @type {TODO} */ (joiner));
-					}
-
-					for (const key of Object.keys(RESULT_MODIFIER)) {
-						const modifier = RESULT_MODIFIER[key];
-						stats.hooks.result
-							.for(key)
-							.tap("DefaultStatsPrinterPlugin", modifier);
-					}
+				for (const key of Object.keys(ITEM_NAMES)) {
+					const itemName = ITEM_NAMES[key];
+					stats.hooks.getItemName
+						.for(key)
+						.tap(
+							PLUGIN_NAME,
+							typeof itemName === "string" ? () => itemName : itemName
+						);
 				}
-			);
+
+				for (const key of Object.keys(SIMPLE_ITEMS_JOINER)) {
+					const joiner = SIMPLE_ITEMS_JOINER[key];
+					stats.hooks.printItems.for(key).tap(PLUGIN_NAME, joiner);
+				}
+
+				for (const key of Object.keys(SIMPLE_ELEMENT_JOINERS)) {
+					const joiner =
+						/** @type {(items: Item[], context: StatsPrinterContext) => string} */
+						(SIMPLE_ELEMENT_JOINERS[key]);
+					stats.hooks.printElements.for(key).tap(PLUGIN_NAME, joiner);
+				}
+
+				for (const key of Object.keys(RESULT_MODIFIER)) {
+					const modifier = RESULT_MODIFIER[key];
+					stats.hooks.result.for(key).tap(PLUGIN_NAME, modifier);
+				}
+			});
 		});
 	}
 }
+
 module.exports = DefaultStatsPrinterPlugin;