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

package/lib/node/ReadFileCompileAsyncWasmPlugin.js

@@ -77,7 +77,11 @@ class ReadFileCompileAsyncWasmPlugin {
 									"",
 									"// Fake fetch response",
 									"resolve({",
-									Template.indent(["arrayBuffer() { return buffer; }"]),
+									Template.indent([
+										// Return a real ArrayBuffer: some runtimes (e.g. Deno)
+										// reject a Node Buffer view here as "not a buffer source".
+										"arrayBuffer() { return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength); }"
+									]),
 									"});"
 								]),
 								"});"
@@ -99,7 +103,11 @@ class ReadFileCompileAsyncWasmPlugin {
 										"",
 										"// Fake fetch response",
 										"resolve({",
-										Template.indent(["arrayBuffer() { return buffer; }"]),
+										Template.indent([
+											// Return a real ArrayBuffer: some runtimes (e.g. Deno)
+											// reject a Node Buffer view here as "not a buffer source".
+											"arrayBuffer() { return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength); }"
+										]),
 										"});"
 									]),
 									"});"

package/lib/node/ReadFileCompileWasmPlugin.js

@@ -77,7 +77,11 @@ class ReadFileCompileWasmPlugin {
 									"",
 									"// Fake fetch response",
 									"resolve({",
-									Template.indent(["arrayBuffer() { return buffer; }"]),
+									Template.indent([
+										// Return a real ArrayBuffer: some runtimes (e.g. Deno)
+										// reject a Node Buffer view here as "not a buffer source".
+										"arrayBuffer() { return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength); }"
+									]),
 									"});"
 								]),
 								"});"
@@ -99,7 +103,11 @@ class ReadFileCompileWasmPlugin {
 										"",
 										"// Fake fetch response",
 										"resolve({",
-										Template.indent(["arrayBuffer() { return buffer; }"]),
+										Template.indent([
+											// Return a real ArrayBuffer: some runtimes (e.g. Deno)
+											// reject a Node Buffer view here as "not a buffer source".
+											"arrayBuffer() { return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength); }"
+										]),
 										"});"
 									]),
 									"});"

package/lib/optimize/AggressiveMergingPlugin.js

@@ -53,8 +53,16 @@ class AggressiveMergingPlugin {
 				},
 				(chunks) => {
 					const chunkGraph = compilation.chunkGraph;
-					/** @type {{ a: Chunk, b: Chunk, improvement: number }[]} */
-					const combinations = [];
+					// Only the single best pair is merged per pass (the hook re-runs
+					// after each merge), so track the max directly instead of building
+					// and sorting the full O(chunks²) list of pairs every pass. A strict
+					// `>` keeps the first-encountered best, matching the previous stable
+					// descending sort's `[0]`.
+					/** @type {Chunk | undefined} */
+					let bestA;
+					/** @type {Chunk | undefined} */
+					let bestB;
+					let bestImprovement = -Infinity;
 					for (const a of chunks) {
 						if (a.canBeInitial()) continue;
 						for (const b of chunks) {
@@ -73,23 +81,19 @@ class AggressiveMergingPlugin {
 								chunkOverhead: 0
 							});
 							const improvement = (aSize + bSize) / abSize;
-							combinations.push({
-								a,
-								b,
-								improvement
-							});
+							if (improvement > bestImprovement) {
+								bestImprovement = improvement;
+								bestA = a;
+								bestB = b;
+							}
 						}
 					}
 
-					combinations.sort((a, b) => b.improvement - a.improvement);
-
-					const pair = combinations[0];
-
-					if (!pair) return;
-					if (pair.improvement < minSizeReduce) return;
+					if (bestA === undefined) return;
+					if (bestImprovement < minSizeReduce) return;
 
-					chunkGraph.integrateChunks(pair.b, pair.a);
-					compilation.chunks.delete(pair.a);
+					chunkGraph.integrateChunks(/** @type {Chunk} */ (bestB), bestA);
+					compilation.chunks.delete(bestA);
 					return true;
 				}
 			);

package/lib/optimize/ConcatenatedModule.js

@@ -99,6 +99,7 @@ const { InlinedUsedName } = require("./InlineExports");
 /** @typedef {import("../javascript/JavascriptModulesPlugin").Variable} Variable */
 /** @typedef {import("../javascript/JavascriptParser").Program} Program */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("estree").Identifier} Identifier */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/Hash").HashFunction} HashFunction */
@@ -1011,16 +1012,17 @@ class ConcatenatedModule extends Module {
 				}
 			}
 
-			// populate dependencies
-			for (const d of m.dependencies.filter(
-				(dep) =>
-					!Dependency.canConcatenate(dep) ||
+			// populate dependencies — keep only deps that leave the concat set
+			for (const d of m.dependencies) {
+				if (
+					!Dependency.canConcatenate(d) ||
 					!this._modules.has(
 						/** @type {Module} */
-						(compilation.moduleGraph.getModule(dep))
+						(compilation.moduleGraph.getModule(d))
 					)
-			)) {
-				this.dependencies.push(d);
+				) {
+					this.dependencies.push(d);
+				}
 			}
 			// populate codeGenerationDependencies — the inner modules'
 			// templates are applied during ConcatenatedModule.codeGeneration,
@@ -1753,10 +1755,12 @@ class ConcatenatedModule extends Module {
 						const newName = _findNewName(name, info, references);
 						if (newName) {
 							const source = /** @type {ReplaceSource} */ (info.source);
-							const allIdentifiers = new Set([
-								...references.map((r) => r.identifier),
-								...variable.identifiers
-							]);
+							/** @type {Set<Identifier>} */
+							const allIdentifiers = new Set();
+							for (const r of references) allIdentifiers.add(r.identifier);
+							for (const identifier of variable.identifiers) {
+								allIdentifiers.add(identifier);
+							}
 							for (const identifier of allIdentifiers) {
 								const r = /** @type {Range} */ (identifier.range);
 								const path = getPathInAst(
@@ -1889,11 +1893,11 @@ class ConcatenatedModule extends Module {
 				const referencesByName = new Map();
 				for (const reference of globalScope.through) {
 					const name = reference.identifier.name;
-					if (!referencesByName.has(name)) {
-						referencesByName.set(name, []);
+					let references = referencesByName.get(name);
+					if (references === undefined) {
+						referencesByName.set(name, (references = []));
 					}
-					/** @type {Reference[]} */
-					(referencesByName.get(name)).push(reference);
+					references.push(reference);
 				}
 				for (const [name, references] of referencesByName) {
 					const match = ConcatenationScope.matchModuleReference(name);

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -70,6 +70,23 @@ const getMergedModuleRuntime = (chunkGraph, cache, module) => {
  * @property {number} added
  */
 
+/**
+ * Record why `module` can't be added (so retried lookups hit the cache), bump
+ * the matching statistic, and return the problem to bubble up the recursion.
+ * Only reached on failure, so it stays off the hot success path.
+ * @param {Map<Module, Problem>} failureCache per-module failure cache
+ * @param {Statistics} statistics running statistics
+ * @param {keyof Statistics} statKey statistic to increment
+ * @param {Module} module the module that couldn't be added
+ * @param {Problem} problem the failure to cache and return
+ * @returns {Problem} the same problem
+ */
+const cacheFailure = (failureCache, statistics, statKey, module, problem) => {
+	statistics[statKey]++;
+	failureCache.set(module, problem);
+	return problem;
+};
+
 /**
  * Format bailout reason.
  * @param {string} msg message
@@ -687,9 +704,13 @@ class ModuleConcatenationPlugin {
 
 		// Not possible to add?
 		if (!possibleModules.has(module)) {
-			statistics.invalidModule++;
-			failureCache.set(module, module); // cache failures for performance
-			return module;
+			return cacheFailure(
+				failureCache,
+				statistics,
+				"invalidModule",
+				module,
+				module
+			);
 		}
 
 		// A deferred import must stay a concatenation boundary: concatenating a
@@ -707,9 +728,13 @@ class ModuleConcatenationPlugin {
 				`Module ${module.readableIdentifier(
 					requestShortener
 				)} imports a module in this configuration via import defer`;
-			statistics.incorrectDependency++;
-			failureCache.set(module, problem); // cache failures for performance
-			return problem;
+			return cacheFailure(
+				failureCache,
+				statistics,
+				"incorrectDependency",
+				module,
+				problem
+			);
 		}
 
 		// Module must be in the correct chunks
@@ -741,9 +766,13 @@ class ModuleConcatenationPlugin {
 					", "
 				)}, module is in chunk(s) ${chunks.join(", ")})`;
 			};
-			statistics.incorrectChunks++;
-			failureCache.set(module, problem); // cache failures for performance
-			return problem;
+			return cacheFailure(
+				failureCache,
+				statistics,
+				"incorrectChunks",
+				module,
+				problem
+			);
 		}
 
 		const moduleGraph = compilation.moduleGraph;
@@ -782,9 +811,13 @@ class ModuleConcatenationPlugin {
 							: "in an unsupported way"
 					}`;
 				};
-				statistics.incorrectDependency++;
-				failureCache.set(module, problem); // cache failures for performance
-				return problem;
+				return cacheFailure(
+					failureCache,
+					statistics,
+					"incorrectDependency",
+					module,
+					problem
+				);
 			}
 		}
 
@@ -841,9 +874,13 @@ class ModuleConcatenationPlugin {
 					", "
 				)}`;
 			};
-			statistics.incorrectChunksOfImporter++;
-			failureCache.set(module, problem); // cache failures for performance
-			return problem;
+			return cacheFailure(
+				failureCache,
+				statistics,
+				"incorrectChunksOfImporter",
+				module,
+				problem
+			);
 		}
 
 		/** @type {Map<Module, ReadonlyArray<ModuleGraph.ModuleGraphConnection>>} */
@@ -893,9 +930,13 @@ class ModuleConcatenationPlugin {
 					", "
 				)}`;
 			};
-			statistics.incorrectModuleDependency++;
-			failureCache.set(module, problem); // cache failures for performance
-			return problem;
+			return cacheFailure(
+				failureCache,
+				statistics,
+				"incorrectModuleDependency",
+				module,
+				problem
+			);
 		}
 
 		if (runtime !== undefined && typeof runtime !== "string") {
@@ -946,9 +987,13 @@ class ModuleConcatenationPlugin {
 								/** @type {RuntimeSpec} */ (runtimeCondition)
 							)})`
 					).join(", ")}`;
-				statistics.incorrectRuntimeCondition++;
-				failureCache.set(module, problem); // cache failures for performance
-				return problem;
+				return cacheFailure(
+					failureCache,
+					statistics,
+					"incorrectRuntimeCondition",
+					module,
+					problem
+				);
 			}
 		}
 
@@ -981,9 +1026,13 @@ class ModuleConcatenationPlugin {
 			);
 			if (problem) {
 				if (backup !== undefined) config.rollback(backup);
-				statistics.importerFailed++;
-				failureCache.set(module, problem); // cache failures for performance
-				return problem;
+				return cacheFailure(
+					failureCache,
+					statistics,
+					"importerFailed",
+					module,
+					problem
+				);
 			}
 		}
 

package/lib/optimize/RealContentHashPlugin.js

@@ -166,10 +166,16 @@ const toCachedSource = (source) => {
  * @property {Hashes} hashes
  */
 
+const createCompilationHooks = () => ({
+	/**
+	 * @type {SyncBailHook<[Buffer[], string], string | void>}
+	 * @since 5.8.0
+	 */
+	updateHash: new SyncBailHook(["content", "oldHash"])
+});
+
 /**
- * Defines the compilation hooks type used by this module.
- * @typedef {object} CompilationHooks
- * @property {SyncBailHook<[Buffer[], string], string | void>} updateHash
+ * @typedef {ReturnType<typeof createCompilationHooks>} CompilationHooks
  */
 
 /**
@@ -554,10 +560,7 @@ ${referencingAssets
 }
 
 RealContentHashPlugin.getCompilationHooks = createHooksRegistry(
-	() =>
-		/** @type {CompilationHooks} */ ({
-			updateHash: new SyncBailHook(["content", "oldHash"])
-		})
+	createCompilationHooks
 );
 
 module.exports = RealContentHashPlugin;

package/lib/optimize/SplitChunksPlugin.js

@@ -182,7 +182,6 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {string=} name
  * @property {SplitChunksSizes} sizes
  * @property {ChunkSet} chunks
- * @property {ChunkSet} reusableChunks
  * @property {Set<bigint | Chunk>} chunksKeys
  */
 
@@ -229,7 +228,6 @@ const getRequests = (chunk) => {
 /**
  * Returns result.
  * @template {object} T
- * @template {object} R
  * @param {T} obj obj an object
  * @param {(obj: T[keyof T], key: keyof T) => T[keyof T]} fn fn
  * @returns {T} result
@@ -314,6 +312,9 @@ const ASYNC_CHUNK_FILTER = (chunk) => !chunk.canBeInitial();
  */
 const ALL_CHUNK_FILTER = (_chunk) => true;
 
+/** Placeholder until a chunk set group is filled and its signatures are written. */
+const EMPTY_SIGNATURES = new Uint32Array(0);
+
 /**
  * Returns normalized representation.
  * @param {OptimizationSplitChunksSizes | undefined} value the sizes
@@ -902,15 +903,21 @@ module.exports = class SplitChunksPlugin {
 					// Give each selected chunk an index (to create strings from chunks)
 					/** @type {Map<Chunk, bigint>} */
 					const chunkIndexMap = new Map();
+					// Dense per-chunk index, folded into the 64 bit membership
+					// signatures that reject non-subsets in getCombinations
+					/** @type {Map<Chunk, number>} */
+					const chunkSignatureBitMap = new Map();
 					const ZERO = BigInt("0");
 					const ONE = BigInt("1");
 					const START = ONE << BigInt("31");
 					let index = START;
+					let denseIndex = 0;
 					for (const chunk of chunks) {
 						chunkIndexMap.set(
 							chunk,
 							index | BigInt((Math.random() * 0x7fffffff) | 0)
 						);
+						chunkSignatureBitMap.set(chunk, denseIndex++ & 63);
 						index <<= ONE;
 					}
 					/**
@@ -1011,7 +1018,36 @@ module.exports = class SplitChunksPlugin {
 						return { chunkSetsInGraph, singleChunkSets };
 					});
 
-					/** @typedef {Map<CountOfChunk, ChunkSet[]>} ChunkSetsByCount */
+					/**
+					 * Chunk sets of equal size, with a 64 bit membership signature
+					 * per set stored as two words at `2 * i` in `signatures`.
+					 * @typedef {object} ChunkSetGroup
+					 * @property {ChunkSet[]} sets the chunk sets
+					 * @property {Uint32Array} signatures two signature words per set
+					 */
+
+					/** @typedef {Map<CountOfChunk, ChunkSetGroup>} ChunkSetsByCount */
+
+					// holds the signature of the set currently being combined; transient
+					const signatureScratch = new Uint32Array(2);
+
+					/**
+					 * Folds a chunk set into a 64 bit membership signature.
+					 * @param {ChunkSet} chunksSet set of chunks
+					 * @param {Uint32Array} out target array
+					 * @param {number} offset index of the first of the two words
+					 * @returns {void}
+					 */
+					const writeSignature = (chunksSet, out, offset) => {
+						out[offset] = 0;
+						out[offset + 1] = 0;
+						for (const chunk of chunksSet) {
+							const bit = /** @type {number} */ (
+								chunkSignatureBitMap.get(chunk)
+							);
+							out[offset + (bit >> 5)] |= 1 << (bit & 31);
+						}
+					};
 
 					// group these set of chunks by count
 					// to allow to check less sets via isSubset
@@ -1026,12 +1062,20 @@ module.exports = class SplitChunksPlugin {
 						const chunkSetsByCount = new Map();
 						for (const chunksSet of chunkSets) {
 							const count = chunksSet.size;
-							let array = chunkSetsByCount.get(count);
-							if (array === undefined) {
-								array = [];
-								chunkSetsByCount.set(count, array);
+							let group = chunkSetsByCount.get(count);
+							if (group === undefined) {
+								group = { sets: [], signatures: EMPTY_SIGNATURES };
+								chunkSetsByCount.set(count, group);
 							}
-							array.push(chunksSet);
+							group.sets.push(chunksSet);
+						}
+						for (const group of chunkSetsByCount.values()) {
+							const { sets } = group;
+							const signatures = new Uint32Array(sets.length * 2);
+							for (let i = 0; i < sets.length; i++) {
+								writeSignature(sets[i], signatures, i * 2);
+							}
+							group.signatures = signatures;
 						}
 						return chunkSetsByCount;
 					};
@@ -1077,10 +1121,24 @@ module.exports = class SplitChunksPlugin {
 								(chunkSets.get(key));
 							/** @type {Combinations} */
 							const array = [chunksSet];
-							for (const [count, setArray] of chunkSetsByCount) {
+							writeSignature(chunksSet, signatureScratch, 0);
+							const selfLow = signatureScratch[0];
+							const selfHigh = signatureScratch[1];
+							for (const [count, group] of chunkSetsByCount) {
 								// "equal" is not needed because they would have been merge in the first step
 								if (count < chunksSet.size) {
-									for (const set of setArray) {
+									const { sets, signatures } = group;
+									for (let i = 0; i < sets.length; i++) {
+										// a subset cannot hold a signature bit the superset lacks,
+										// so this rejects nearly every candidate without touching the Set
+										const offset = i * 2;
+										if (
+											(signatures[offset] & ~selfLow) !== 0 ||
+											(signatures[offset + 1] & ~selfHigh) !== 0
+										) {
+											continue;
+										}
+										const set = sets[i];
 										if (isSubset(chunksSet, set)) {
 											array.push(set);
 										}
@@ -1187,6 +1245,31 @@ module.exports = class SplitChunksPlugin {
 					/** @type {Map<string, ChunksInfoItem>} */
 					const chunksInfoMap = new Map();
 
+					// The unnamed key is derived only from cache group and chunk set, so it
+					// repeats for every module sharing that pair — build the string once
+					/** @type {Map<CacheGroup, Map<bigint | Chunk, string>>} */
+					const unnamedKeyCache = new Map();
+
+					/**
+					 * Returns the chunksInfoMap key for a cache group and chunk set.
+					 * @param {CacheGroup} cacheGroup the current cache group
+					 * @param {bigint | Chunk} selectedChunksKey a key of selectedChunks
+					 * @returns {string} key into chunksInfoMap
+					 */
+					const getUnnamedKey = (cacheGroup, selectedChunksKey) => {
+						let byChunksKey = unnamedKeyCache.get(cacheGroup);
+						if (byChunksKey === undefined) {
+							byChunksKey = new Map();
+							unnamedKeyCache.set(cacheGroup, byChunksKey);
+						}
+						let key = byChunksKey.get(selectedChunksKey);
+						if (key === undefined) {
+							key = `${cacheGroup.key} chunks:${keyToString(selectedChunksKey)}`;
+							byChunksKey.set(selectedChunksKey, key);
+						}
+						return key;
+					};
+
 					/**
 					 * Adds module to chunks info map.
 					 * @param {CacheGroup} cacheGroup the current cache group
@@ -1270,11 +1353,9 @@ module.exports = class SplitChunksPlugin {
 						// When it has a name we use the name as key
 						// Otherwise we create the key from chunks and cache group key
 						// This automatically merges equal names
-						const key =
-							cacheGroup.key +
-							(name
-								? ` name:${name}`
-								: ` chunks:${keyToString(selectedChunksKey)}`);
+						const key = name
+							? `${cacheGroup.key} name:${name}`
+							: getUnnamedKey(cacheGroup, selectedChunksKey);
 						// Add module to maps
 						let info = chunksInfoMap.get(key);
 						if (info === undefined) {
@@ -1290,7 +1371,6 @@ module.exports = class SplitChunksPlugin {
 									name,
 									sizes: {},
 									chunks: new Set(),
-									reusableChunks: new Set(),
 									chunksKeys: new Set()
 								})
 							);
@@ -1316,6 +1396,35 @@ module.exports = class SplitChunksPlugin {
 						chunkGraph
 					};
 
+					/**
+					 * Returns combinations of the chunks the module is in.
+					 * @param {Module} module the module
+					 * @returns {Combinations} chunk combinations
+					 */
+					const computeCombinations = (module) =>
+						getCombinations(getKey(chunkGraph.getModuleChunksIterable(module)));
+
+					/**
+					 * Returns combinations of the module's chunks grouped by used exports.
+					 * @param {Module} module the module
+					 * @returns {Set<ChunkSet | Chunk>} chunk combinations
+					 */
+					const computeCombinationsByUsedExports = (module) => {
+						// fill the groupedByExportsMap
+						getExportsChunkSetsInGraph();
+						/** @type {Set<ChunkSet | Chunk>} */
+						const set = new Set();
+						const groupedByUsedExports =
+							/** @type {Iterable<Chunk[]>} */
+							(groupedByExportsMap.get(module));
+						for (const chunks of groupedByUsedExports) {
+							for (const comb of getExportsCombinations(getKey(chunks))) {
+								set.add(comb);
+							}
+						}
+						return set;
+					};
+
 					logger.timeEnd("prepare");
 
 					logger.time("modules");
@@ -1328,38 +1437,29 @@ module.exports = class SplitChunksPlugin {
 							continue;
 						}
 
-						// Prepare some values (usedExports = false)
-						const getCombs = memoize(() => {
-							const chunks = chunkGraph.getModuleChunksIterable(module);
-							const chunksKey = getKey(chunks);
-							return getCombinations(chunksKey);
-						});
-
-						// Prepare some values (usedExports = true)
-						const getCombsByUsedExports = memoize(() => {
-							// fill the groupedByExportsMap
-							getExportsChunkSetsInGraph();
-							/** @type {Set<ChunkSet | Chunk>} */
-							const set = new Set();
-							const groupedByUsedExports =
-								/** @type {Iterable<Chunk[]>} */
-								(groupedByExportsMap.get(module));
-							for (const chunks of groupedByUsedExports) {
-								const chunksKey = getKey(chunks);
-								for (const comb of getExportsCombinations(chunksKey)) {
-									set.add(comb);
-								}
-							}
-							return set;
-						});
+						// Computed at most once per module, on first use by a cache group
+						/** @type {Combinations | undefined} */
+						let combsCache;
+						/** @type {Set<ChunkSet | Chunk> | undefined} */
+						let combsByUsedExportsCache;
 
 						let cacheGroupIndex = 0;
 						for (const cacheGroupSource of cacheGroups) {
 							const cacheGroup = this._getCacheGroup(cacheGroupSource);
 
-							const combs = cacheGroup.usedExports
-								? getCombsByUsedExports()
-								: getCombs();
+							let combs;
+							if (cacheGroup.usedExports) {
+								if (combsByUsedExportsCache === undefined) {
+									combsByUsedExportsCache =
+										computeCombinationsByUsedExports(module);
+								}
+								combs = combsByUsedExportsCache;
+							} else {
+								if (combsCache === undefined) {
+									combsCache = computeCombinations(module);
+								}
+								combs = combsCache;
+							}
 							// For all combination of chunk selection
 							for (const chunkCombination of combs) {
 								// Break if minimum number of chunks is not reached
@@ -1577,12 +1677,14 @@ module.exports = class SplitChunksPlugin {
 							}
 							if (usedChunks.size >= item.cacheGroup.minChunks) {
 								const chunksArr = [...usedChunks];
+								// invariant across the module loop below
+								const usedChunksKey = getKey(usedChunks);
 								for (const module of item.modules) {
 									addModuleToChunksInfoMap(
 										item.cacheGroup,
 										item.cacheGroupIndex,
 										chunksArr,
-										getKey(usedChunks),
+										usedChunksKey,
 										module
 									);
 								}