@depup/webpack 5.110.3-depup.0 → 5.111.1-depup.0

package/lib/optimize/ConstExportsPlugin.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const CircularModulesPlugin = require("../CircularModulesPlugin");
 const { UsageState } = require("../ExportsInfo");
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
@@ -15,10 +16,11 @@ const { VariableInfoFlags } = require("../javascript/JavascriptParser");
 const {
 	InlinedUsedName,
 	enableInlineExports,
-	findModulesInCycles,
 	toInlinedValue
 } = require("./InlineExports");
 
+const { CircularKind } = CircularModulesPlugin;
+
 /** @import { InlinedValue } from "./InlineExports" */
 /** @import Compiler from "../Compiler" */
 /** @import ExportsInfo from "../ExportsInfo" */
@@ -162,54 +164,63 @@ class ConstExportsPlugin {
 				enableInlineExports(compilation.moduleGraph);
 
 				const moduleGraph = compilation.moduleGraph;
-				compilation.hooks.optimizeDependencies.tap(PLUGIN_NAME, (modules) => {
-					// A cycle peer may read an export during its temporal dead zone,
-					// where the binding must throw and a literal would answer.
-					const inCycle = findModulesInCycles(moduleGraph, modules);
-					/** @type {Set<ExportsInfo>} */
-					const visited = new Set();
-					/** @type {ExportsInfo[]} */
-					let queue = [];
-					for (const module of modules) {
-						if (inCycle.has(module)) continue;
-						queue.push(moduleGraph.getExportsInfo(module));
-					}
-					while (queue.length > 0) {
-						const items = queue;
-						queue = [];
-						for (const exportsInfo of items) {
-							if (visited.has(exportsInfo)) continue;
-							visited.add(exportsInfo);
-							// Other-export usage means we can't safely inline (some non-statically-known consumer)
+				// After CircularModulesPlugin (STAGE_DETECT): needs Binding kind flags.
+				compilation.hooks.optimizeDependencies.tap(
+					{
+						name: PLUGIN_NAME,
+						stage: CircularModulesPlugin.STAGE_DETECT + 1
+					},
+					(modules) => {
+						/** @type {Set<ExportsInfo>} */
+						const visited = new Set();
+						/** @type {ExportsInfo[]} */
+						let queue = [];
+						for (const module of modules) {
+							// Binding-observable cycle peers must keep TDZ live bindings.
 							if (
-								exportsInfo.otherExportsInfo.getUsed(undefined) !==
-								UsageState.Unused
+								CircularModulesPlugin.isCircular(module, CircularKind.Binding)
 							) {
 								continue;
 							}
-							for (const exportInfo of exportsInfo.ownedExports) {
-								const inlined = exportInfo.canInline();
-								const doInline =
-									!exportInfo.hasUsedName() &&
-									inlined !== undefined &&
-									exportInfo.provided === true;
-								if (doInline) {
-									exportInfo.setUsedName(new InlinedUsedName(inlined));
-									exportsInfo.markInlinedExports();
+							queue.push(moduleGraph.getExportsInfo(module));
+						}
+						while (queue.length > 0) {
+							const items = queue;
+							queue = [];
+							for (const exportsInfo of items) {
+								if (visited.has(exportsInfo)) continue;
+								visited.add(exportsInfo);
+								// Other-export usage means we can't safely inline (some non-statically-known consumer)
+								if (
+									exportsInfo.otherExportsInfo.getUsed(undefined) !==
+									UsageState.Unused
+								) {
+									continue;
 								}
-								if (exportInfo.exportsInfoOwned && exportInfo.exportsInfo) {
-									const used = exportInfo.getUsed(undefined);
-									if (
-										used === UsageState.OnlyPropertiesUsed ||
-										used === UsageState.Unused
-									) {
-										queue.push(exportInfo.exportsInfo);
+								for (const exportInfo of exportsInfo.ownedExports) {
+									const inlined = exportInfo.canInline();
+									const doInline =
+										!exportInfo.hasUsedName() &&
+										inlined !== undefined &&
+										exportInfo.provided === true;
+									if (doInline) {
+										exportInfo.setUsedName(new InlinedUsedName(inlined));
+										exportsInfo.markInlinedExports();
+									}
+									if (exportInfo.exportsInfoOwned && exportInfo.exportsInfo) {
+										const used = exportInfo.getUsed(undefined);
+										if (
+											used === UsageState.OnlyPropertiesUsed ||
+											used === UsageState.Unused
+										) {
+											queue.push(exportInfo.exportsInfo);
+										}
 									}
 								}
 							}
 						}
 					}
-				});
+				);
 			}
 		);
 	}

package/lib/optimize/FlagIncludedChunksPlugin.js

@@ -24,17 +24,9 @@ class FlagIncludedChunksPlugin {
 			compilation.hooks.optimizeChunkIds.tap(PLUGIN_NAME, (chunks) => {
 				const chunkGraph = compilation.chunkGraph;
 
-				// prepare two bit integers for each module
-				// 2^31 is the max number represented as SMI in v8
-				// we want the bits distributed this way:
-				// the bit 2^31 is pretty rar and only one module should get it
-				// so it has a probability of 1 / modulesCount
-				// the first bit (2^0) is the easiest and every module could get it
-				// if it doesn't get a better bit
-				// from bit 2^n to 2^(n+1) there is a probability of p
-				// so 1 / modulesCount == p^31
-				// <=> p = sqrt31(1 / modulesCount)
-				// so we use a modulo of 1 / sqrt31(1 / modulesCount)
+				// Two bit integers per module, within v8's 2^31 SMI range. The bits are
+				// spread so 2^31 falls to about one module in `modulesCount` and 2^0 to
+				// any module missing a better one, which gives the modulo below.
 				/** @type {WeakMap<Module, number>} */
 				const moduleBits = new WeakMap();
 				const modulesCount = compilation.modules.size;

package/lib/optimize/InlineExports.js

@@ -17,6 +17,7 @@ const { propertyAccess } = require("../util/property");
 /** @import ModuleGraph from "../ModuleGraph" */
 /** @import Module from "../Module" */
 /** @import { RuntimeSpec } from "../util/runtime" */
+/** @import Hash from "../util/Hash" */
 
 const MAX_INLINE_BYTES = 6;
 
@@ -60,6 +61,14 @@ class InlinedValue {
 		return `(${comment}${this.renderLiteral()})`;
 	}
 
+	/**
+	 * @param {InlinedValue} other other inlined value
+	 * @returns {boolean} true when kind and value match
+	 */
+	equals(other) {
+		return this.kind === other.kind && this.value === other.value;
+	}
+
 	/**
 	 * @param {ObjectSerializerContext} context context
 	 */
@@ -96,12 +105,21 @@ class InlinedUsedName {
 	}
 
 	/**
-	 * @param {string} comment leading comment text
+	 * @param {string=} comment leading comment text
 	 * @returns {string} rendered literal with property access suffix
 	 */
-	render(comment) {
+	render(comment = "") {
 		return this.value.render(comment) + propertyAccess(this.suffix);
 	}
+
+	/**
+	 * Updates the hash with the data contributed by this instance.
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @returns {void}
+	 */
+	updateHash(hash) {
+		hash.update(this.render());
+	}
 }
 
 /**
@@ -172,131 +190,10 @@ const isExportInlined = (moduleGraph, module, ids, runtime) => {
 	return moduleGraph.getExportsInfo(module).hasInlinedUsedName(ids, runtime);
 };
 
-/**
- * Collects, by an iterative Tarjan pass, the modules a cycle peer may read in
- * their dead zone. A cycle of bare side-effect imports still inlines.
- * @param {ModuleGraph} moduleGraph module graph
- * @param {Iterable<Module>} modules all modules of the compilation
- * @returns {Set<Module>} modules whose exports must not be inlined
- */
-const findModulesInCycles = (moduleGraph, modules) => {
-	const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
-	const HarmonyImportSideEffectDependency = require("../dependencies/HarmonyImportSideEffectDependency");
-
-	/** @type {Set<Module>} */
-	const inCycle = new Set();
-	/** @type {[Module, Module][]} */
-	const bindingReads = [];
-	/** @type {Map<Module, number>} */
-	const componentOf = new Map();
-	let nextComponent = 0;
-	/** @type {Map<Module, number>} */
-	const index = new Map();
-	/** @type {Map<Module, number>} */
-	const low = new Map();
-	/** @type {Set<Module>} */
-	const onStack = new Set();
-	/** @type {Module[]} */
-	const componentStack = [];
-	let counter = 0;
-	/**
-	 * @param {Module} module the module
-	 * @returns {Module[]} modules it imports, self included when self-importing
-	 */
-	const targetsOf = (module) => {
-		const connections = moduleGraph.getOutgoingConnectionsByModule(module);
-		if (!connections) return [];
-		/** @type {Module[]} */
-		const targets = [];
-		for (const [target, moduleConnections] of connections) {
-			if (
-				!target ||
-				!moduleConnections.some(
-					(c) => c.dependency instanceof HarmonyImportDependency
-				)
-			) {
-				continue;
-			}
-			// Anything but a bare side-effect import may observe the binding.
-			if (
-				moduleConnections.some(
-					(c) =>
-						c.dependency instanceof HarmonyImportDependency &&
-						!(c.dependency instanceof HarmonyImportSideEffectDependency)
-				)
-			) {
-				bindingReads.push([module, target]);
-			}
-			targets.push(target);
-		}
-		return targets;
-	};
-	/** @type {{ node: Module, targets: Module[], i: number }[]} */
-	const work = [];
-	/**
-	 * @param {Module} node node to open
-	 */
-	const open = (node) => {
-		index.set(node, counter);
-		low.set(node, counter);
-		counter++;
-		componentStack.push(node);
-		onStack.add(node);
-		work.push({ node, targets: targetsOf(node), i: 0 });
-	};
-	for (const seed of modules) {
-		if (index.has(seed)) continue;
-		open(seed);
-		while (work.length > 0) {
-			const frame = work[work.length - 1];
-			if (frame.i < frame.targets.length) {
-				const next = frame.targets[frame.i++];
-				if (!index.has(next)) {
-					open(next);
-				} else if (onStack.has(next)) {
-					const nodeLow = /** @type {number} */ (low.get(frame.node));
-					const nextIndex = /** @type {number} */ (index.get(next));
-					if (nextIndex < nodeLow) low.set(frame.node, nextIndex);
-				}
-				continue;
-			}
-			work.pop();
-			const node = frame.node;
-			const nodeLow = /** @type {number} */ (low.get(node));
-			if (work.length > 0) {
-				const parent = work[work.length - 1].node;
-				if (nodeLow < /** @type {number} */ (low.get(parent))) {
-					low.set(parent, nodeLow);
-				}
-			}
-			if (nodeLow === index.get(node)) {
-				const id = nextComponent++;
-				let member;
-				do {
-					member = /** @type {Module} */ (componentStack.pop());
-					onStack.delete(member);
-					componentOf.set(member, id);
-				} while (member !== node);
-			}
-		}
-	}
-	// Reader and target evaluate together exactly when they share a component.
-	for (const [origin, target] of bindingReads) {
-		if (
-			origin === target ||
-			componentOf.get(origin) === componentOf.get(target)
-		) {
-			inCycle.add(target);
-		}
-	}
-	return inCycle;
-};
-
 module.exports.InlinedUsedName = InlinedUsedName;
 module.exports.InlinedValue = InlinedValue;
 module.exports.MAX_INLINE_BYTES = MAX_INLINE_BYTES;
 module.exports.enableInlineExports = enableInlineExports;
-module.exports.findModulesInCycles = findModulesInCycles;
 module.exports.isExportInlined = isExportInlined;
 module.exports.isInlineEnabled = isInlineEnabled;
 module.exports.isInlineExportsEnabled = isInlineExportsEnabled;

package/lib/optimize/InnerGraphPlugin.js

@@ -122,10 +122,8 @@ class InnerGraphPlugin {
 					// nodes that have a TopLevelSymbol assigned and
 					// variables are tagged with the assigned TopLevelSymbol
 
-					// We differ 3 types of nodes:
-					// 1. full statements (export default, function declaration)
-					// 2. classes (class declaration, class expression)
-					// 3. variable declarators (const x = ...)
+					// Three kinds of node carry a symbol: a full statement, a class, and a
+					// variable declarator.
 
 					/** @type {WeakMap<Node | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration, TopLevelSymbol>} */
 					let statementWithTopLevelSymbol = new WeakMap();
@@ -360,16 +358,12 @@ class InnerGraphPlugin {
 					// During real walking we set the TopLevelSymbol state to the assigned
 					// TopLevelSymbol by using the fill datastructures.
 
-					// In addition to tracking TopLevelSymbols, we sometimes need to
-					// add a PureExpressionDependency. This is needed to skip execution
-					// of pure expressions, even when they are not dropped due to
-					// minimizing. Otherwise symbols used there might not exist anymore
-					// as they are removed as unused by this optimization
+					// A `PureExpressionDependency` is sometimes added too, so a pure
+					// expression is skipped even where minimizing leaves it: the symbols it
+					// uses may have been removed as unused by this optimization.
 
-					// When we find a reference to a TopLevelSymbol, we register a
-					// TopLevelSymbol dependency from TopLevelSymbol in state to the
-					// referenced TopLevelSymbol. This way we get a graph of all
-					// TopLevelSymbols.
+					// A reference registers a dependency from the symbol in state to the one
+					// referenced, which is how the graph of all of them is built.
 
 					// The following hooks are called during walking:
 

package/lib/optimize/LimitChunkCountPlugin.js

@@ -101,10 +101,8 @@ class LimitChunkCountPlugin {
 					/** @type {Chunk[]} */
 					const orderedChunks = [...chunks].sort(compareChunksWithGraph);
 
-					// create a lazy sorted data structure to keep all combinations
-					// this is large. Size = chunks * (chunks - 1) / 2
-					// It uses a multi layer bucket sort plus normal sort in the last layer
-					// It's also lazy so only accessed buckets are sorted
+					// All `chunks * (chunks - 1) / 2` combinations, held in a multi-layer
+					// bucket sort that sorts only the buckets actually reached.
 					/** @type {LazyBucketSortedSet<ChunkCombination, number>} */
 					const combinations = new LazyBucketSortedSet(
 						// Layer 1: ordered by largest size benefit
@@ -214,10 +212,9 @@ class LimitChunkCountPlugin {
 							for (const group of queue) {
 								for (const mChunk of modifiedChunks) {
 									if (mChunk !== a && mChunk !== b && mChunk.isInGroup(group)) {
-										// This is a potential pair which needs recalculation
-										// We can't do that now, but it merge before following pairs
-										// so we leave space for it, and consider chunks as modified
-										// just for the worse case
+										// A pair needing recalculation, which cannot happen now yet may
+										// merge before the ones that follow, so room is left for it and
+										// the chunks count as modified for the worst case.
 										remainingChunksToMerge--;
 										if (remainingChunksToMerge <= 0) break loop;
 										modifiedChunks.add(a);

package/lib/optimize/MangleExportsPlugin.js

@@ -15,6 +15,7 @@ const { assignDeterministicIds } = require("../ids/IdHelpers");
 const { compareSelect, compareStringsNumeric } = require("../util/comparators");
 
 /** @import Compiler from "../Compiler" */
+/** @import { BuildInfo } from "../Module" */
 /** @import ExportsInfo, { ExportInfo } from "../ExportsInfo" */
 /** @import { UsedNames } from "../util/concatenate" */
 
@@ -59,10 +60,9 @@ const mangleExportsInfo = (deterministic, exportsInfo, isNamespace) => {
 	/** @type {InstanceType<ExportInfo>[]} */
 	const mangleableExports = [];
 
-	// Avoid to renamed exports that are not provided when
-	// 1. it's not a namespace export: non-provided exports can be found in prototype chain
-	// 2. there are other provided exports and deterministic mode is chosen:
-	//    non-provided exports would break the determinism
+	// A non-provided export is left unmangled outside a namespace export, where the
+	// prototype chain may still carry it, and under deterministic mode beside other
+	// provided exports, where it would break the determinism.
 	let avoidMangleNonProvided = !isNamespace;
 	if (!avoidMangleNonProvided && deterministic) {
 		for (const exportInfo of exportsInfo.ownedExports) {
@@ -184,6 +184,15 @@ class MangleExportsPlugin {
 					);
 				}
 				for (const module of modules) {
+					// A spec namespace reports the names the module exports, so a
+					// module handing one out cannot have them renamed.
+					if (
+						/** @type {BuildInfo} */
+						(module.buildInfo).specNamespaceObject
+					) {
+						continue;
+					}
+
 					const isNamespace =
 						module.buildMeta && module.buildMeta.exportsType === "namespace";
 					const exportsInfo = moduleGraph.getExportsInfo(module);

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -5,7 +5,6 @@
 
 "use strict";
 
-const asyncLib = require("neo-async");
 const ChunkGraph = require("../ChunkGraph");
 const Dependency = require("../Dependency");
 const Module = require("../Module");
@@ -14,6 +13,7 @@ const { JAVASCRIPT_TYPE } = require("../ModuleSourceTypeConstants");
 const { STAGE_DEFAULT } = require("../OptimizationStages");
 const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
 const { ImportPhaseUtils } = require("../dependencies/ImportPhase");
+const asyncLib = require("../util/async");
 const { compareModulesByIdentifier } = require("../util/comparators");
 const { isCommonJsConcatenationEnabled } = require("../util/concatenate");
 const {
@@ -28,6 +28,7 @@ const ConcatenatedModule = require("./ConcatenatedModule");
 /** @import Chunk from "../Chunk" */
 /** @import Compilation from "../Compilation" */
 /** @import Compiler from "../Compiler" */
+/** @import { JavascriptModuleBuildInfo } from "../javascript/JavascriptModule" */
 /** @import { BuildInfo, BuildMeta } from "../Module" */
 /** @import RequestShortener from "../RequestShortener" */
 /** @import { RuntimeSpec } from "../util/runtime" */
@@ -235,6 +236,19 @@ class ModuleConcatenationPlugin {
 							continue;
 						}
 
+						// Concatenation materializes the namespace inline, which would
+						// silently drop the spec exotic object the module asked for.
+						if (
+							/** @type {BuildInfo} */
+							(module.buildInfo).specNamespaceObject
+						) {
+							setBailoutReason(
+								module,
+								"Module hands out a spec namespace object"
+							);
+							continue;
+						}
+
 						// Module must be in any chunk (we don't want to do useless work)
 						if (chunkGraph.getNumberOfModuleChunks(module) === 0) {
 							setBailoutReason(module, "Module is not in any chunk");
@@ -302,6 +316,15 @@ class ModuleConcatenationPlugin {
 							canBeInner = false;
 						}
 
+						// The root stands in for the whole concatenation, so an
+						// expression only an inner module can answer statically rules it out
+						if (
+							/** @type {JavascriptModuleBuildInfo} */
+							(module.buildInfo).moduleConcatenationRootBailout
+						) {
+							canBeRoot = false;
+						}
+
 						if (deferEnabled && moduleGraph.isDeferred(module)) {
 							setInnerBailoutReason(module, "Module is deferred");
 							canBeInner = false;
@@ -455,10 +478,9 @@ class ModuleConcatenationPlugin {
 					logger.debug(
 						`${statsCandidates} candidates were considered for adding (${stats.cached} cached failure, ${stats.alreadyInConfig} already in config, ${stats.invalidModule} invalid module, ${stats.incorrectChunks} incorrect chunks, ${stats.incorrectDependency} incorrect dependency, ${stats.incorrectChunksOfImporter} incorrect chunks of importer, ${stats.incorrectModuleDependency} incorrect module dependency, ${stats.incorrectRuntimeCondition} incorrect runtime condition, ${stats.importerFailed} importer failed, ${stats.added} added)`
 					);
-					// Create the largest configurations first: if a root also ended up inside
-					// a bigger configuration, the bigger one wins (smaller skipped below).
-					// Configurations can't be reused across roots: a module shared by several
-					// chunks is concatenated into each consumer (module duplication).
+					// Largest configurations first, so a root that also landed inside a
+					// bigger one loses to it. None is reused across roots: a module shared by
+					// several chunks is concatenated into each consumer.
 					logger.time("sort concat configurations");
 					concatConfigurations.sort((a, b) => b.modules.size - a.modules.size);
 					logger.timeEnd("sort concat configurations");

package/lib/optimize/RealContentHashPlugin.js

@@ -187,6 +187,7 @@ const createCompilationHooks = () => ({
  * @typedef {object} RealContentHashPluginOptions
  * @property {HashFunction} hashFunction the hash function to use
  * @property {HashDigest} hashDigest the hash digest to use
+ * @property {boolean=} onDemand run only where analyzable output marked a name for repair
  */
 
 const PLUGIN_NAME = "RealContentHashPlugin";
@@ -196,11 +197,13 @@ class RealContentHashPlugin {
 	 * Creates an instance of RealContentHashPlugin.
 	 * @param {RealContentHashPluginOptions} options options
 	 */
-	constructor({ hashFunction, hashDigest }) {
+	constructor({ hashFunction, hashDigest, onDemand }) {
 		/** @type {HashFunction} */
 		this._hashFunction = hashFunction;
 		/** @type {HashDigest} */
 		this._hashDigest = hashDigest;
+		/** @type {boolean} */
+		this._onDemand = Boolean(onDemand);
 	}
 
 	/**
@@ -223,6 +226,14 @@ class RealContentHashPlugin {
 					stage: Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_HASH
 				},
 				async () => {
+					// Set by the deferred fill where a baked name would leave a hashed name
+					// stale; only then is `[chunkhash]` repaired rather than left as named.
+					const repairing = compilation.runtimeTemplate.needsAnalyzableRepair();
+					if (this._onDemand && !repairing) return;
+					// On demand, only a name the fill left stale moves, and whatever names it.
+					const repairedAssets = this._onDemand
+						? compilation.runtimeTemplate.analyzableRepairedAssets()
+						: undefined;
 					const assets = compilation.getAssets();
 					/** @type {AssetInfoForRealContentHash[]} */
 					const assetsWithInfo = [];
@@ -238,6 +249,7 @@ class RealContentHashPlugin {
 						/** @type {Hashes} */
 						const hashes = new Set();
 						addToList(info.contenthash, hashes);
+						if (repairing) addToList(info.chunkhash, hashes);
 						if (info.contenthashDigest) {
 							for (const hash of Object.keys(info.contenthashDigest)) {
 								hashToDigest.set(hash, info.contenthashDigest[hash]);
@@ -495,7 +507,44 @@ ${referencingAssets
 					};
 					/** @type {Comparator<AssetInfoForRealContentHash>} */
 					const comparator = compareSelect((a) => a.name, compareStrings);
+					/**
+					 * Whether a group's names went stale: the fill rewrote an asset of theirs, or
+					 * one names a hash that already moved (groups arrive dependencies first).
+					 * @param {string[]} group the hashes assigned together
+					 * @returns {boolean} true when they have to be recomputed
+					 */
+					const staleOnDemand = (group) => {
+						const own = new Set(group);
+						for (const hash of group) {
+							for (const asset of /** @type {AssetInfoForRealContentHash[]} */ (
+								hashToAssets.get(hash)
+							)) {
+								if (
+									/** @type {ReadonlySet<string>} */ (repairedAssets).has(
+										asset.name
+									)
+								) {
+									return true;
+								}
+								for (const referenced of /** @type {Hashes} */ (
+									asset.referencedHashes
+								)) {
+									if (
+										!own.has(referenced) &&
+										hashToNewHash.get(referenced) !== referenced
+									) {
+										return true;
+									}
+								}
+							}
+						}
+						return false;
+					};
 					for (const group of groupsInOrder) {
+						if (repairedAssets !== undefined && !staleOnDemand(group)) {
+							for (const hash of group) hashToNewHash.set(hash, hash);
+							continue;
+						}
 						// A cycle is assigned as one group: members are told apart by stable
 						// markers, so the group hashes to a fixed point instead of chasing one.
 						if (group.length > 1) {
@@ -608,15 +657,25 @@ ${referencingAssets
 								(hash) => /** @type {string} */ (hashToNewHash.get(hash))
 							);
 
+							/**
+							 * @param {string | string[]} hash what the asset was named with
+							 * @returns {string | string[]} the same, repaired
+							 */
+							const repaired = (hash) =>
+								Array.isArray(hash)
+									? hash.map(
+											(hash) => /** @type {string} */ (hashToNewHash.get(hash))
+										)
+									: /** @type {string} */ (hashToNewHash.get(hash));
+							/** @type {AssetInfo} */
 							const infoUpdate = {};
-							const hash =
-								/** @type {Exclude<AssetInfo["contenthash"], undefined>} */
-								(asset.info.contenthash);
-							infoUpdate.contenthash = Array.isArray(hash)
-								? hash.map(
-										(hash) => /** @type {string} */ (hashToNewHash.get(hash))
-									)
-								: /** @type {string} */ (hashToNewHash.get(hash));
+							if (asset.info.contenthash) {
+								infoUpdate.contenthash = repaired(asset.info.contenthash);
+							}
+							// Tracked only while repairing, so only then does it move with the name.
+							if (repairing && asset.info.chunkhash) {
+								infoUpdate.chunkhash = repaired(asset.info.chunkhash);
+							}
 
 							if (asset.newSource !== undefined) {
 								compilation.updateAsset(