@depup/webpack 5.106.1-depup.0 → 5.109.2-depup.0

package/lib/stats/DefaultStatsFactoryPlugin.js

@@ -6,9 +6,9 @@
 "use strict";
 
 const util = require("util");
+const { version: WEBPACK_VERSION } = require("../../package.json");
 const { WEBPACK_MODULE_TYPE_RUNTIME } = require("../ModuleTypeConstants");
 const ModuleDependency = require("../dependencies/ModuleDependency");
-const formatLocation = require("../formatLocation");
 const { LogType } = require("../logging/Logger");
 const AggressiveSplittingPlugin = require("../optimize/AggressiveSplittingPlugin");
 const SizeLimitsPlugin = require("../performance/SizeLimitsPlugin");
@@ -22,6 +22,7 @@ const {
 	compareSelect,
 	concatComparators
 } = require("../util/comparators");
+const formatLocation = require("../util/formatLocation");
 const { makePathsRelative, parseResource } = require("../util/identifier");
 
 /** @typedef {import("webpack-sources").Source} Source */
@@ -46,25 +47,29 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").NameForCondition} NameForCondition */
 /** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("../ModuleProfile")} ModuleProfile */
-/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../errors/WebpackError")} WebpackError */
 /** @typedef {import("../serialization/AggregateErrorSerializer").AggregateError} AggregateError */
 /** @typedef {import("../serialization/ErrorObjectSerializer").ErrorWithCause} ErrorWithCause */
 /** @typedef {import("../ExportsInfo").ExportInfoName} ExportInfoName */
 
 /**
+ * Defines the shared type used by this module.
  * @template T
  * @typedef {import("../util/comparators").Comparator<T>} Comparator<T>
  */
 
 /**
+ * Defines the group config type used by this module.
  * @template I, G
  * @typedef {import("../util/smartGrouping").GroupConfig<I, G>} GroupConfig
  */
 
 /** @typedef {KnownStatsCompilation & Record<string, EXPECTED_ANY>} StatsCompilation */
 /**
+ * Defines the known stats compilation type used by this module.
  * @typedef {object} KnownStatsCompilation
  * @property {EXPECTED_ANY=} env
  * @property {string=} name
@@ -95,6 +100,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 
 /** @typedef {KnownStatsLogging & Record<string, EXPECTED_ANY>} StatsLogging */
 /**
+ * Defines the known stats logging type used by this module.
  * @typedef {object} KnownStatsLogging
  * @property {StatsLoggingEntry[]} entries
  * @property {number} filteredEntries
@@ -103,6 +109,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 
 /** @typedef {KnownStatsLoggingEntry & Record<string, EXPECTED_ANY>} StatsLoggingEntry */
 /**
+ * Defines the known stats logging entry type used by this module.
  * @typedef {object} KnownStatsLoggingEntry
  * @property {string} type
  * @property {string=} message
@@ -115,6 +122,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 /** @typedef {KnownStatsAsset & Record<string, EXPECTED_ANY>} StatsAsset */
 /** @typedef {string[]} ChunkIdHints */
 /**
+ * Defines the known stats asset type used by this module.
  * @typedef {object} KnownStatsAsset
  * @property {string} type
  * @property {string} name
@@ -136,6 +144,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 
 /** @typedef {KnownStatsChunkGroup & Record<string, EXPECTED_ANY>} StatsChunkGroup */
 /**
+ * Defines the known stats chunk group type used by this module.
  * @typedef {object} KnownStatsChunkGroup
  * @property {ChunkName=} name
  * @property {ChunkId[]=} chunks
@@ -153,6 +162,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 /** @typedef {Module[]} ModuleIssuerPath */
 /** @typedef {KnownStatsModule & Record<string, EXPECTED_ANY>} StatsModule */
 /**
+ * Defines the known stats module type used by this module.
  * @typedef {object} KnownStatsModule
  * @property {string=} type
  * @property {string=} moduleType
@@ -167,6 +177,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {number=} size
  * @property {Record<string, number>=} sizes
  * @property {boolean=} cacheable
+ * @property {string[]=} notCacheableReasons
  * @property {boolean=} built
  * @property {boolean=} codeGenerated
  * @property {boolean=} buildTimeExecuted
@@ -197,6 +208,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 
 /** @typedef {KnownStatsProfile & Record<string, EXPECTED_ANY>} StatsProfile */
 /**
+ * Defines the known stats profile type used by this module.
  * @typedef {object} KnownStatsProfile
  * @property {number} total
  * @property {number} resolving
@@ -212,6 +224,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 
 /** @typedef {KnownStatsModuleIssuer & Record<string, EXPECTED_ANY>} StatsModuleIssuer */
 /**
+ * Defines the known stats module issuer type used by this module.
  * @typedef {object} KnownStatsModuleIssuer
  * @property {string} identifier
  * @property {string} name
@@ -221,6 +234,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 
 /** @typedef {KnownStatsModuleReason & Record<string, EXPECTED_ANY>} StatsModuleReason */
 /**
+ * Defines the known stats module reason type used by this module.
  * @typedef {object} KnownStatsModuleReason
  * @property {string | null} moduleIdentifier
  * @property {string | null} module
@@ -238,6 +252,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 
 /** @typedef {KnownStatsChunk & Record<string, EXPECTED_ANY>} StatsChunk */
 /**
+ * Defines the known stats chunk type used by this module.
  * @typedef {object} KnownStatsChunk
  * @property {boolean} rendered
  * @property {boolean} initial
@@ -264,6 +279,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 
 /** @typedef {KnownStatsChunkOrigin & Record<string, EXPECTED_ANY>} StatsChunkOrigin */
 /**
+ * Defines the known stats chunk origin type used by this module.
  * @typedef {object} KnownStatsChunkOrigin
  * @property {string} module
  * @property {string} moduleIdentifier
@@ -275,6 +291,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 
 /** @typedef {KnownStatsModuleTraceItem & Record<string, EXPECTED_ANY>} StatsModuleTraceItem */
 /**
+ * Defines the known stats module trace item type used by this module.
  * @typedef {object} KnownStatsModuleTraceItem
  * @property {string=} originIdentifier
  * @property {string=} originName
@@ -287,12 +304,14 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 
 /** @typedef {KnownStatsModuleTraceDependency & Record<string, EXPECTED_ANY>} StatsModuleTraceDependency */
 /**
+ * Defines the known stats module trace dependency type used by this module.
  * @typedef {object} KnownStatsModuleTraceDependency
  * @property {string=} loc
  */
 
 /** @typedef {KnownStatsError & Record<string, EXPECTED_ANY>} StatsError */
 /**
+ * Defines the known stats error type used by this module.
  * @typedef {object} KnownStatsError
  * @property {string} message
  * @property {string=} chunkName
@@ -315,6 +334,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 /** @typedef {Asset & { type: string, related: PreprocessedAsset[] | undefined }} PreprocessedAsset */
 
 /**
+ * Defines the extractors by option type used by this module.
  * @template T
  * @template O
  * @typedef {Record<string, (object: O, data: T, context: StatsFactoryContext, options: NormalizedStatsOptions, factory: StatsFactory) => void>} ExtractorsByOption
@@ -324,6 +344,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 /** @typedef {{ origin: Module, module: Module }} ModuleTrace */
 
 /**
+ * Defines the simple extractors type used by this module.
  * @typedef {object} SimpleExtractors
  * @property {ExtractorsByOption<Compilation, StatsCompilation>} compilation
  * @property {ExtractorsByOption<PreprocessedAsset, StatsAsset>} asset
@@ -344,6 +365,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  */
 
 /**
+ * Returns array of values.
  * @template T
  * @template I
  * @param {Iterable<T>} items items to select from
@@ -362,6 +384,7 @@ const uniqueArray = (items, selector) => {
 };
 
 /**
+ * Unique ordered array.
  * @template T
  * @template I
  * @param {Iterable<T>} items items to select from
@@ -373,12 +396,14 @@ const uniqueOrderedArray = (items, selector, comparator) =>
 	uniqueArray(items, selector).sort(comparator);
 
 /**
+ * Defines the shared type used by this module.
  * @template T
  * @template R
  * @typedef {{ [P in keyof T]: R }} MappedValues<T, R>
  */
 
 /**
+ * Returns mapped object.
  * @template {object} T
  * @template {object} R
  * @param {T} obj object to be mapped
@@ -395,9 +420,9 @@ const mapObject = (obj, fn) => {
 };
 
 /**
- * @template T
+ * Count with children.
  * @param {Compilation} compilation the compilation
- * @param {(compilation: Compilation, name: string) => T[]} getItems get items
+ * @param {(compilation: Compilation, name: string) => { length: number }} getItems get items
  * @returns {number} total number
  */
 const countWithChildren = (compilation, getItems) => {
@@ -730,7 +755,7 @@ const SIMPLE_EXTRACTORS = {
 			object.hash = compilation.hash;
 		},
 		version: (object) => {
-			object.version = require("../../package.json").version;
+			object.version = WEBPACK_VERSION;
 		},
 		env: (object, compilation, context, { _env }) => {
 			object.env = _env;
@@ -810,22 +835,24 @@ const SIMPLE_EXTRACTORS = {
 			}
 
 			object.assetsByChunkName = {};
-			for (const [file, chunks] of [
-				...compilationFileToChunks,
-				...compilationAuxiliaryFileToChunks
+			for (const fileToChunks of [
+				compilationFileToChunks,
+				compilationAuxiliaryFileToChunks
 			]) {
-				for (const chunk of chunks) {
-					const name = chunk.name;
-					if (!name) continue;
-					if (
-						!Object.prototype.hasOwnProperty.call(
-							object.assetsByChunkName,
-							name
-						)
-					) {
-						object.assetsByChunkName[name] = [];
+				for (const [file, chunks] of fileToChunks) {
+					for (const chunk of chunks) {
+						const name = chunk.name;
+						if (!name) continue;
+						if (
+							!Object.prototype.hasOwnProperty.call(
+								object.assetsByChunkName,
+								name
+							)
+						) {
+							object.assetsByChunkName[name] = [];
+						}
+						object.assetsByChunkName[name].push(file);
 					}
-					object.assetsByChunkName[name].push(file);
 				}
 			}
 
@@ -987,17 +1014,16 @@ const SIMPLE_EXTRACTORS = {
 			const { type, cachedGetWarnings } = context;
 			object.warningsCount = countWithChildren(compilation, (c, childType) => {
 				if (
-					!warningsFilter &&
 					/** @type {KnownNormalizedStatsOptions["warningsFilter"]} */
 					(warningsFilter).length === 0
 				) {
-					// Type is wrong, because we don't need the real value for counting
-					return /** @type {EXPECTED_ANY[]} */ (cachedGetWarnings(c));
+					return cachedGetWarnings(c);
 				}
 				return factory
 					.create(`${type}${childType}.warnings`, cachedGetWarnings(c), context)
 					.filter(
 						/**
+						 * Handles the warnings count callback for this hook.
 						 * @param {StatsError} warning warning
 						 * @returns {boolean} result
 						 */
@@ -1122,6 +1148,7 @@ const SIMPLE_EXTRACTORS = {
 				chunkGroupChildren &&
 				chunkGroup.getChildrenByOrders(moduleGraph, chunkGraph);
 			/**
+			 * Returns } Asset object.
 			 * @param {string} name Name
 			 * @returns {{ name: string, size: number }} Asset object
 			 */
@@ -1221,6 +1248,25 @@ const SIMPLE_EXTRACTORS = {
 		},
 		performance: (object, { chunkGroup }) => {
 			object.isOverSizeLimit = SizeLimitsPlugin.isOverSizeLimit(chunkGroup);
+		},
+		chunkGroupResourceHints: (
+			object,
+			{ name, chunkGroup },
+			{ compilation }
+		) => {
+			// SSR frameworks consume this to inject the initial-chunk +
+			// URL-asset `<link>` tags into their server-rendered HTML without
+			// having to walk the chunk graph themselves. Only entrypoints
+			// carry hints; split-chunk / async chunk groups are skipped.
+			if (!compilation.entrypoints.get(name)) return;
+
+			const ResourceHintPlugin = require("../prefetch/ResourceHintPlugin");
+
+			const hints =
+				ResourceHintPlugin.getCompilationResolver(
+					compilation
+				).getEntrypointHints(name);
+			if (hints.length > 0) object.resourceHints = hints;
 		}
 	},
 	module: {
@@ -1236,19 +1282,16 @@ const SIMPLE_EXTRACTORS = {
 			for (const sourceType of module.getSourceTypes()) {
 				sizes[sourceType] = module.size(sourceType);
 			}
-			/** @type {KnownStatsModule} */
-			const statsModule = {
-				type: "module",
-				moduleType: module.type,
-				layer: module.layer,
-				size: module.size(),
-				sizes,
-				built,
-				codeGenerated,
-				buildTimeExecuted,
-				cached: !built && !codeGenerated
-			};
-			Object.assign(object, statsModule);
+			// assign fields directly to avoid an intermediate object + copy per module
+			object.type = "module";
+			object.moduleType = module.type;
+			object.layer = module.layer;
+			object.size = module.size();
+			object.sizes = sizes;
+			object.built = built;
+			object.codeGenerated = codeGenerated;
+			object.buildTimeExecuted = buildTimeExecuted;
+			object.cached = !built && !codeGenerated;
 			if (built || codeGenerated || options.cachedModules) {
 				Object.assign(
 					object,
@@ -1277,36 +1320,43 @@ const SIMPLE_EXTRACTORS = {
 			const warnings = module.getWarnings();
 			const warningsCount =
 				warnings !== undefined ? countIterable(warnings) : 0;
-			/** @type {KnownStatsModule} */
-			const statsModule = {
-				identifier: module.identifier(),
-				name: module.readableIdentifier(requestShortener),
-				nameForCondition: module.nameForCondition(),
-				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") &&
-					compilation.chunkGraph.getNumberOfModuleChunks(module) === 0,
-				dependent: rootModules ? !rootModules.has(module) : undefined,
-				issuer: issuer && issuer.identifier(),
-				issuerName: issuer && issuer.readableIdentifier(requestShortener),
-				issuerPath:
-					issuer &&
-					/** @type {StatsModuleIssuer[] | undefined} */
-					(factory.create(`${type.slice(0, -8)}.issuerPath`, path, context)),
-				failed: errorsCount > 0,
-				errors: errorsCount,
-				warnings: warningsCount
-			};
-			Object.assign(object, statsModule);
+			const { cacheable, notCacheableReasons } = /** @type {BuildInfo} */ (
+				module.buildInfo
+			);
+			const preOrderIndex = /** @type {number} */ (
+				moduleGraph.getPreOrderIndex(module)
+			);
+			const postOrderIndex = /** @type {number} */ (
+				moduleGraph.getPostOrderIndex(module)
+			);
+			// assign fields directly to avoid an intermediate object + copy per module
+			object.identifier = module.identifier();
+			object.name = module.readableIdentifier(requestShortener);
+			object.nameForCondition = module.nameForCondition();
+			object.index = preOrderIndex;
+			object.preOrderIndex = preOrderIndex;
+			object.index2 = postOrderIndex;
+			object.postOrderIndex = postOrderIndex;
+			object.cacheable = cacheable;
+			object.notCacheableReasons =
+				notCacheableReasons &&
+				notCacheableReasons.map(
+					(request) => /** @type {string} */ (requestShortener.shorten(request))
+				);
+			object.optional = module.isOptional(moduleGraph);
+			object.orphan =
+				!type.endsWith("module.modules[].module$visible") &&
+				compilation.chunkGraph.getNumberOfModuleChunks(module) === 0;
+			object.dependent = rootModules ? !rootModules.has(module) : undefined;
+			object.issuer = issuer && issuer.identifier();
+			object.issuerName = issuer && issuer.readableIdentifier(requestShortener);
+			object.issuerPath =
+				issuer &&
+				/** @type {StatsModuleIssuer[] | undefined} */
+				(factory.create(`${type.slice(0, -8)}.issuerPath`, path, context));
+			object.failed = errorsCount > 0;
+			object.errors = errorsCount;
+			object.warnings = warningsCount;
 			if (profile) {
 				object.profile = factory.create(
 					`${type.slice(0, -8)}.profile`,
@@ -1418,27 +1468,24 @@ const SIMPLE_EXTRACTORS = {
 	},
 	profile: {
 		_: (object, profile) => {
-			/** @type {KnownStatsProfile} */
-			const statsProfile = {
-				total:
-					profile.factory +
-					profile.restoring +
-					profile.integration +
-					profile.building +
-					profile.storing,
-				resolving: profile.factory,
-				restoring: profile.restoring,
-				building: profile.building,
-				integration: profile.integration,
-				storing: profile.storing,
-				additionalResolving: profile.additionalFactories,
-				additionalIntegration: profile.additionalIntegration,
-				// TODO remove this in webpack 6
-				factory: profile.factory,
-				// TODO remove this in webpack 6
-				dependencies: profile.additionalFactories
-			};
-			Object.assign(object, statsProfile);
+			// assign fields directly to avoid an intermediate object + copy
+			object.total =
+				profile.factory +
+				profile.restoring +
+				profile.integration +
+				profile.building +
+				profile.storing;
+			object.resolving = profile.factory;
+			object.restoring = profile.restoring;
+			object.building = profile.building;
+			object.integration = profile.integration;
+			object.storing = profile.storing;
+			object.additionalResolving = profile.additionalFactories;
+			object.additionalIntegration = profile.additionalIntegration;
+			// TODO remove this in webpack 6
+			object.factory = profile.factory;
+			// TODO remove this in webpack 6
+			object.dependencies = profile.additionalFactories;
 		}
 	},
 	moduleIssuer: {
@@ -1447,12 +1494,9 @@ const SIMPLE_EXTRACTORS = {
 			const compilation = /** @type {Compilation} */ (context.compilation);
 			const { moduleGraph } = compilation;
 			const profile = moduleGraph.getProfile(module);
-			/** @type {Partial<KnownStatsModuleIssuer>} */
-			const statsModuleIssuer = {
-				identifier: module.identifier(),
-				name: module.readableIdentifier(requestShortener)
-			};
-			Object.assign(object, statsModuleIssuer);
+			// assign fields directly to avoid an intermediate object + copy per issuer
+			object.identifier = module.identifier();
+			object.name = module.readableIdentifier(requestShortener);
 			if (profile) {
 				object.profile = factory.create(`${type}.profile`, profile, context);
 			}
@@ -1466,31 +1510,26 @@ const SIMPLE_EXTRACTORS = {
 			const dep = reason.dependency;
 			const moduleDep =
 				dep && dep instanceof ModuleDependency ? dep : undefined;
-			/** @type {KnownStatsModuleReason} */
-			const statsModuleReason = {
-				moduleIdentifier: reason.originModule
-					? reason.originModule.identifier()
-					: null,
-				module: reason.originModule
-					? reason.originModule.readableIdentifier(requestShortener)
-					: null,
-				moduleName: reason.originModule
-					? reason.originModule.readableIdentifier(requestShortener)
-					: null,
-				resolvedModuleIdentifier: reason.resolvedOriginModule
-					? reason.resolvedOriginModule.identifier()
-					: null,
-				resolvedModule: reason.resolvedOriginModule
-					? reason.resolvedOriginModule.readableIdentifier(requestShortener)
-					: null,
-				type: reason.dependency ? reason.dependency.type : null,
-				active: reason.isActive(runtime),
-				explanation: reason.explanation,
-				userRequest: (moduleDep && moduleDep.userRequest) || null
-			};
-			Object.assign(object, statsModuleReason);
-			if (reason.dependency) {
-				const locInfo = formatLocation(reason.dependency.loc);
+			const { originModule, resolvedOriginModule } = reason;
+			const originName = originModule
+				? originModule.readableIdentifier(requestShortener)
+				: null;
+			// assign fields directly to avoid an intermediate object + copy per reason
+			object.moduleIdentifier = originModule ? originModule.identifier() : null;
+			object.module = originName;
+			object.moduleName = originName;
+			object.resolvedModuleIdentifier = resolvedOriginModule
+				? resolvedOriginModule.identifier()
+				: null;
+			object.resolvedModule = resolvedOriginModule
+				? resolvedOriginModule.readableIdentifier(requestShortener)
+				: null;
+			object.type = dep ? dep.type : null;
+			object.active = reason.isActive(runtime);
+			object.explanation = reason.explanation;
+			object.userRequest = (moduleDep && moduleDep.userRequest) || null;
+			if (dep) {
+				const locInfo = formatLocation(dep.loc);
 				if (locInfo) {
 					object.loc = locInfo;
 				}
@@ -1509,29 +1548,26 @@ const SIMPLE_EXTRACTORS = {
 		_: (object, chunk, { makePathsRelative, compilation: { chunkGraph } }) => {
 			const childIdByOrder = chunk.getChildIdsByOrders(chunkGraph);
 
-			/** @type {KnownStatsChunk} */
-			const statsChunk = {
-				rendered: chunk.rendered,
-				initial: chunk.canBeInitial(),
-				entry: chunk.hasRuntime(),
-				recorded: AggressiveSplittingPlugin.wasChunkRecorded(chunk),
-				reason: chunk.chunkReason,
-				size: chunkGraph.getChunkModulesSize(chunk),
-				sizes: chunkGraph.getChunkModulesSizes(chunk),
-				names: chunk.name ? [chunk.name] : [],
-				idHints: [...chunk.idNameHints],
-				runtime:
-					chunk.runtime === undefined
-						? undefined
-						: typeof chunk.runtime === "string"
-							? [makePathsRelative(chunk.runtime)]
-							: Array.from(chunk.runtime.sort(), makePathsRelative),
-				files: [...chunk.files],
-				auxiliaryFiles: [...chunk.auxiliaryFiles].sort(compareIds),
-				hash: /** @type {string} */ (chunk.renderedHash),
-				childrenByOrder: childIdByOrder
-			};
-			Object.assign(object, statsChunk);
+			// assign fields directly to avoid an intermediate object + copy per chunk
+			object.rendered = chunk.rendered;
+			object.initial = chunk.canBeInitial();
+			object.entry = chunk.hasRuntime();
+			object.recorded = AggressiveSplittingPlugin.wasChunkRecorded(chunk);
+			object.reason = chunk.chunkReason;
+			object.size = chunkGraph.getChunkModulesSize(chunk);
+			object.sizes = chunkGraph.getChunkModulesSizes(chunk);
+			object.names = chunk.name ? [chunk.name] : [];
+			object.idHints = [...chunk.idNameHints];
+			object.runtime =
+				chunk.runtime === undefined
+					? undefined
+					: typeof chunk.runtime === "string"
+						? [makePathsRelative(chunk.runtime)]
+						: Array.from(chunk.runtime.sort(), makePathsRelative);
+			object.files = [...chunk.files];
+			object.auxiliaryFiles = [...chunk.auxiliaryFiles].sort(compareIds);
+			object.hash = /** @type {string} */ (chunk.renderedHash);
+			object.childrenByOrder = childIdByOrder;
 		},
 		ids: (object, chunk) => {
 			object.id = /** @type {ChunkId} */ (chunk.id);
@@ -1608,17 +1644,16 @@ const SIMPLE_EXTRACTORS = {
 	},
 	chunkOrigin: {
 		_: (object, origin, context, { requestShortener }) => {
-			/** @type {KnownStatsChunkOrigin} */
-			const statsChunkOrigin = {
-				module: origin.module ? origin.module.identifier() : "",
-				moduleIdentifier: origin.module ? origin.module.identifier() : "",
-				moduleName: origin.module
-					? origin.module.readableIdentifier(requestShortener)
-					: "",
-				loc: formatLocation(origin.loc),
-				request: origin.request
-			};
-			Object.assign(object, statsChunkOrigin);
+			const originModule = origin.module;
+			const identifier = originModule ? originModule.identifier() : "";
+			// assign fields directly to avoid an intermediate object + copy per origin
+			object.module = identifier;
+			object.moduleIdentifier = identifier;
+			object.moduleName = originModule
+				? originModule.readableIdentifier(requestShortener)
+				: "";
+			object.loc = formatLocation(origin.loc);
+			object.request = origin.request;
 		},
 		ids: (object, origin, { compilation: { chunkGraph } }) => {
 			object.moduleId = origin.module
@@ -1639,13 +1674,16 @@ const SIMPLE_EXTRACTORS = {
 			object.originName = origin.readableIdentifier(requestShortener);
 			object.moduleIdentifier = module.identifier();
 			object.moduleName = module.readableIdentifier(requestShortener);
-			const dependencies = [...moduleGraph.getIncomingConnections(module)]
-				.filter((c) => c.resolvedOriginModule === origin && c.dependency)
-				.map((c) => c.dependency);
+			/** @type {Set<Dependency>} */
+			const dependencies = new Set();
+			for (const c of moduleGraph.getIncomingConnections(module)) {
+				if (c.resolvedOriginModule === origin && c.dependency) {
+					dependencies.add(c.dependency);
+				}
+			}
 			object.dependencies = factory.create(
 				`${type}.dependencies`,
-				/** @type {Dependency[]} */
-				([...new Set(dependencies)]),
+				[...dependencies],
 				context
 			);
 		},
@@ -1697,17 +1735,50 @@ const FILTER_RESULTS = {
 	}
 };
 
+// module sort selectors close over moduleGraph, so cache the built comparators per
+// moduleGraph (stable per compilation) instead of rebuilding them on every sort
+/** @type {WeakMap<ModuleGraph, Comparator<Module>[]>} */
+const modulesSorterCache = new WeakMap();
+
 /** @type {Record<string, (comparators: Comparator<Module>[], context: StatsFactoryContext) => void>} */
 const MODULES_SORTER = {
 	_: (comparators, { compilation: { moduleGraph } }) => {
-		comparators.push(
-			compareSelect((m) => moduleGraph.getDepth(m), compareNumbers),
-			compareSelect((m) => moduleGraph.getPreOrderIndex(m), compareNumbers),
-			compareSelect((m) => m.identifier(), compareIds)
-		);
+		let cached = modulesSorterCache.get(moduleGraph);
+		if (cached === undefined) {
+			cached = [
+				compareSelect((m) => moduleGraph.getDepth(m), compareNumbers),
+				compareSelect((m) => moduleGraph.getPreOrderIndex(m), compareNumbers),
+				compareSelect((m) => m.identifier(), compareIds)
+			];
+			modulesSorterCache.set(moduleGraph, cached);
+		}
+		comparators.push(...cached);
 	}
 };
 
+// reason comparators use only pure selectors, so build them once instead of per
+// module.reasons sort (which runs once per module and otherwise thrashes the caches)
+/** @type {Comparator<ModuleGraphConnection>[]} */
+const MODULE_REASONS_COMPARATORS = [
+	compareSelect((x) => x.originModule, compareModulesByIdentifier),
+	compareSelect((x) => x.resolvedOriginModule, compareModulesByIdentifier),
+	compareSelect(
+		(x) => x.dependency,
+		concatComparators(
+			compareSelect(
+				/**
+				 * Handles the callback for this hook.
+				 * @param {Dependency} x dependency
+				 * @returns {DependencyLocation} location
+				 */
+				(x) => x.loc,
+				compareLocations
+			),
+			compareSelect((x) => x.type, compareIds)
+		)
+	)
+];
+
 /**
  * @type {{
  * "compilation.chunks": Record<string, (comparators: Comparator<Chunk>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>,
@@ -1730,29 +1801,8 @@ const SORTERS = {
 	"chunk.modules": MODULES_SORTER,
 	"module.modules": MODULES_SORTER,
 	"module.reasons": {
-		_: (comparators, _context) => {
-			comparators.push(
-				compareSelect((x) => x.originModule, compareModulesByIdentifier)
-			);
-			comparators.push(
-				compareSelect((x) => x.resolvedOriginModule, compareModulesByIdentifier)
-			);
-			comparators.push(
-				compareSelect(
-					(x) => x.dependency,
-					concatComparators(
-						compareSelect(
-							/**
-							 * @param {Dependency} x dependency
-							 * @returns {DependencyLocation} location
-							 */
-							(x) => x.loc,
-							compareLocations
-						),
-						compareSelect((x) => x.type, compareIds)
-					)
-				)
-			);
+		_: (comparators) => {
+			comparators.push(...MODULE_REASONS_COMPARATORS);
 		}
 	},
 	"chunk.origins": {
@@ -1771,11 +1821,13 @@ const SORTERS = {
 };
 
 /**
+ * Defines the children type used by this module.
  * @template T
  * @typedef {T & { children?: Children<T>[] | undefined, filteredChildren?: number }} Children
  */
 
 /**
+ * Returns item size.
  * @template T
  * @param {Children<T>} item item
  * @returns {number} item size
@@ -1791,6 +1843,7 @@ const getItemSize = (item) =>
 			: 1 + getTotalSize(item.children);
 
 /**
+ * Returns total size.
  * @template T
  * @param {Children<T>[]} children children
  * @returns {number} total size
@@ -1804,6 +1857,7 @@ const getTotalSize = (children) => {
 };
 
 /**
+ * Returns total items.
  * @template T
  * @param {Children<T>[]} children children
  * @returns {number} total items
@@ -1822,6 +1876,7 @@ const getTotalItems = (children) => {
 };
 
 /**
+ * Returns collapsed children.
  * @template T
  * @param {Children<T>[]} children children
  * @returns {Children<T>[]} collapsed children
@@ -1847,6 +1902,7 @@ const collapse = (children) => {
 };
 
 /**
+ * Returns result.
  * @template T
  * @param {Children<T>[]} itemsAndGroups item and groups
  * @param {number} max max
@@ -1976,6 +2032,7 @@ const spaceLimited = (
 };
 
 /**
+ * Errors space limit.
  * @param {StatsError[]} errors errors
  * @param {number} max max
  * @returns {[StatsError[], number]} error space limit
@@ -2019,7 +2076,7 @@ const errorsSpaceLimit = (errors, max) => {
 				for (; i < errors.length; i++) {
 					const error = errors[i];
 					if (typeof error === "string" || !error.details) result.push(error);
-					result.push({ ...error, details: "" });
+					else result.push({ ...error, details: "" });
 				}
 				break;
 			} else if (fullLength === max) {
@@ -2028,7 +2085,7 @@ const errorsSpaceLimit = (errors, max) => {
 				for (; i < errors.length; i++) {
 					const error = errors[i];
 					if (typeof error === "string" || !error.details) result.push(error);
-					result.push({ ...error, details: "" });
+					else result.push({ ...error, details: "" });
 				}
 				break;
 			}
@@ -2039,6 +2096,7 @@ const errorsSpaceLimit = (errors, max) => {
 };
 
 /**
+ * Returns } asset size.
  * @template {{ size: number }} T
  * @param {T[]} children children
  * @param {T[]} assets assets
@@ -2055,6 +2113,7 @@ const assetGroup = (children, assets) => {
 /** @typedef {{ size: number, sizes: Record<string, number> }} ModuleGroupBySizeResult */
 
 /**
+ * Returns size and sizes.
  * @template {ModuleGroupBySizeResult} T
  * @param {Children<T>[]} children children
  * @param {KnownStatsModule[]} modules modules
@@ -2077,6 +2136,7 @@ const moduleGroup = (children, modules) => {
 };
 
 /**
+ * Returns } reason group.
  * @template {{ active: boolean }} T
  * @param {Children<T>[]} children children
  * @param {KnownStatsModuleReason[]} reasons reasons
@@ -2098,6 +2158,7 @@ const GROUP_PATH_REGEXP = /(.+)[/\\][^/\\]+?(?:\?|(?: \+ \d+ modules?)?$)/;
 /** @typedef {{ type: string }} BaseGroup */
 
 /**
+ * Defines the base group with children type used by this module.
  * @template T
  * @typedef {BaseGroup & { children: T[], size: number }} BaseGroupWithChildren
  */
@@ -2105,6 +2166,7 @@ const GROUP_PATH_REGEXP = /(.+)[/\\][^/\\]+?(?:\?|(?: \+ \d+ modules?)?$)/;
 /** @typedef {(name: string, asset: StatsAsset) => boolean} AssetFilterItemFn */
 
 /**
+ * Describes the assets groupers shape.
  * @typedef {{
  * _: (groupConfigs: GroupConfig<KnownStatsAsset, BaseGroup & { filteredChildren: number, size: number } | BaseGroupWithChildren<KnownStatsAsset>>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void,
  * groupAssetsByInfo: (groupConfigs: GroupConfig<KnownStatsAsset, BaseGroupWithChildren<KnownStatsAsset>>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void,
@@ -2117,6 +2179,7 @@ const GROUP_PATH_REGEXP = /(.+)[/\\][^/\\]+?(?:\?|(?: \+ \d+ modules?)?$)/;
 const ASSETS_GROUPERS = {
 	_: (groupConfigs, context, options) => {
 		/**
+		 * Processes the provided name.
 		 * @param {keyof KnownStatsAsset} name name
 		 * @param {boolean=} exclude need exclude?
 		 */
@@ -2196,6 +2259,7 @@ const ASSETS_GROUPERS = {
 	},
 	groupAssetsByInfo: (groupConfigs, _context, _options) => {
 		/**
+		 * Group by asset info flag.
 		 * @param {string} name name
 		 */
 		const groupByAssetInfoFlag = (name) => {
@@ -2218,6 +2282,7 @@ const ASSETS_GROUPERS = {
 	},
 	groupAssetsByChunk: (groupConfigs, _context, _options) => {
 		/**
+		 * Processes the provided name.
 		 * @param {keyof KnownStatsAsset} name name
 		 */
 		const groupByNames = (name) => {
@@ -2257,6 +2322,7 @@ const ASSETS_GROUPERS = {
 };
 
 /**
+ * Describes the modules groupers shape.
  * @typedef {{
  * _: (groupConfigs: GroupConfig<KnownStatsModule, BaseGroup & { filteredChildren?: number, children?: KnownStatsModule[], size: number, sizes: Record<string, number> }>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void,
  * excludeModules: (groupConfigs: GroupConfig<KnownStatsModule, BaseGroup & { filteredChildren: number, size: number, sizes: Record<string, number> }>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void,
@@ -2271,6 +2337,7 @@ const ASSETS_GROUPERS = {
 const MODULES_GROUPERS = (type) => ({
 	_: (groupConfigs, context, options) => {
 		/**
+		 * Processes the provided name.
 		 * @param {keyof KnownStatsModule} name name
 		 * @param {string} type type
 		 * @param {boolean=} exclude need exclude?
@@ -2452,6 +2519,7 @@ const MODULES_GROUPERS = (type) => ({
 });
 
 /**
+ * Defines the module reasons groupers type used by this module.
  * @typedef {{ groupReasonsByOrigin: (groupConfigs: GroupConfig<KnownStatsModuleReason, BaseGroup & { module: string, children: KnownStatsModuleReason[], active: boolean }>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void }} ModuleReasonsGroupers
  */
 
@@ -2493,6 +2561,7 @@ const RESULT_GROUPERS = {
 
 // remove a prefixed "!" that can be specified to reverse sort order
 /**
+ * Normalizes field key.
  * @param {string} field a field name
  * @returns {field} normalized field
  */
@@ -2505,6 +2574,7 @@ const normalizeFieldKey = (field) => {
 
 // if a field is prefixed by a "!" reverse sort order
 /**
+ * Sorts order regular.
  * @param {string} field a field name
  * @returns {boolean} result
  */
@@ -2516,50 +2586,62 @@ const sortOrderRegular = (field) => {
 };
 
 /**
+ * Returns zero.
+ * @param {EXPECTED_ANY} a first
+ * @param {EXPECTED_ANY} b second
+ * @returns {-1 | 0 | 1} zero
+ */
+const noSort = (a, b) => 0;
+
+/** @type {Map<string, (a: EXPECTED_ANY, b: EXPECTED_ANY) => 0 | 1 | -1>} */
+const sortByFieldCache = new Map();
+
+/**
+ * Returns comparators.
  * @template T
  * @param {string | false} field field name
  * @returns {(a: T, b: T) => 0 | 1 | -1} comparators
  */
 const sortByField = (field) => {
-	if (!field) {
-		/**
-		 * @param {T} a first
-		 * @param {T} b second
-		 * @returns {-1 | 0 | 1} zero
-		 */
-		const noSort = (a, b) => 0;
-		return noSort;
-	}
+	if (!field) return noSort;
+
+	// memoize per field: the comparator (and its selector) is pure, so building it
+	// once keeps compareSelect's cache warm instead of allocating a new entry per sort
+	let sortFn = sortByFieldCache.get(field);
+	if (sortFn !== undefined) return sortFn;
 
 	const fieldKey = normalizeFieldKey(field);
 
-	let sortFn = compareSelect((m) => m[fieldKey], compareIds);
+	sortFn = compareSelect((m) => m[fieldKey], compareIds);
 
 	// if a field is prefixed with a "!" the sort is reversed!
-	const sortIsRegular = sortOrderRegular(field);
-
-	if (!sortIsRegular) {
+	if (!sortOrderRegular(field)) {
 		const oldSortFn = sortFn;
 		sortFn = (a, b) => oldSortFn(b, a);
 	}
 
+	sortByFieldCache.set(field, sortFn);
 	return sortFn;
 };
 
 /**
+ * Describes the asset sorters shape.
  * @typedef {{
  * assetsSort: (comparators: Comparator<Asset>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void,
  * _: (comparators: Comparator<Asset>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void,
  * }} AssetSorters
  */
 
+/** @type {Comparator<Asset>} */
+const compareAssetsByName = compareSelect((asset) => asset.name, compareIds);
+
 /** @type {AssetSorters} */
 const ASSET_SORTERS = {
 	assetsSort: (comparators, context, { assetsSort }) => {
 		comparators.push(sortByField(assetsSort));
 	},
 	_: (comparators) => {
-		comparators.push(compareSelect((a) => a.name, compareIds));
+		comparators.push(compareAssetsByName);
 	}
 };
 
@@ -2599,11 +2681,13 @@ const RESULT_SORTERS = {
 };
 
 /**
+ * Defines the extract function type used by this module.
  * @template T
  * @typedef {T extends Record<string, Record<string, infer F>> ? F : never} ExtractFunction
  */
 
 /**
+ * Processes the provided config.
  * @template {Record<string, Record<string, EXPECTED_ANY>>} T
  * @param {T} config the config see above
  * @param {NormalizedStatsOptions} options stats options
@@ -2658,11 +2742,13 @@ const ITEM_NAMES = {
 };
 
 /**
+ * Defines the named object type used by this module.
  * @template T
  * @typedef {{ name: T }} NamedObject
  */
 
 /**
+ * Merges the provided values into a single result.
  * @template {{ name: string }} T
  * @param {T[]} items items to be merged
  * @returns {NamedObject<T>} an object
@@ -2688,7 +2774,7 @@ const PLUGIN_NAME = "DefaultStatsFactoryPlugin";
 
 class DefaultStatsFactoryPlugin {
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -2697,6 +2783,7 @@ class DefaultStatsFactoryPlugin {
 			compilation.hooks.statsFactory.tap(
 				PLUGIN_NAME,
 				/**
+				 * Handles the callback logic for this hook.
 				 * @param {StatsFactory} stats stats factory
 				 * @param {NormalizedStatsOptions} options stats options
 				 */
@@ -2758,6 +2845,7 @@ class DefaultStatsFactoryPlugin {
 								.tap(
 									PLUGIN_NAME,
 									/**
+									 * Handles the callback logic for this hook.
 									 * @param {Compilation} comp compilation
 									 * @param {StatsFactoryContext} options options
 									 * @returns {StatsFactory | undefined} stats factory