webpack 5.59.0 → 5.94.0

package/lib/optimize/RealContentHashPlugin.js

@@ -13,11 +13,18 @@ const { compareSelect, compareStrings } = require("../util/comparators");
 const createHash = require("../util/createHash");
 
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Cache").Etag} Etag */
 /** @typedef {import("../Compilation").AssetInfo} AssetInfo */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {typeof import("../util/Hash")} Hash */
 
 const EMPTY_SET = new Set();
 
+/**
+ * @template T
+ * @param {T | T[]} itemOrItems item or items
+ * @param {Set<T>} list list
+ */
 const addToList = (itemOrItems, list) => {
 	if (Array.isArray(itemOrItems)) {
 		for (const item of itemOrItems) {
@@ -54,12 +61,14 @@ const mapAndDeduplicateBuffers = (input, fn) => {
  * @param {string} str String to quote
  * @returns {string} Escaped string
  */
-const quoteMeta = str => {
-	return str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
-};
+const quoteMeta = str => str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
 
 const cachedSourceMap = new WeakMap();
 
+/**
+ * @param {Source} source source
+ * @returns {CachedSource} cached source
+ */
 const toCachedSource = source => {
 	if (source instanceof CachedSource) {
 		return source;
@@ -71,23 +80,27 @@ const toCachedSource = source => {
 	return newSource;
 };
 
+/** @typedef {Set<string>} OwnHashes */
+/** @typedef {Set<string>} ReferencedHashes */
+/** @typedef {Set<string>} Hashes */
+
 /**
- * @typedef {Object} AssetInfoForRealContentHash
+ * @typedef {object} AssetInfoForRealContentHash
  * @property {string} name
  * @property {AssetInfo} info
  * @property {Source} source
  * @property {RawSource | undefined} newSource
  * @property {RawSource | undefined} newSourceWithoutOwn
  * @property {string} content
- * @property {Set<string>} ownHashes
- * @property {Promise} contentComputePromise
- * @property {Promise} contentComputeWithoutOwnPromise
- * @property {Set<string>} referencedHashes
- * @property {Set<string>} hashes
+ * @property {OwnHashes | undefined} ownHashes
+ * @property {Promise<void> | undefined} contentComputePromise
+ * @property {Promise<void> | undefined} contentComputeWithoutOwnPromise
+ * @property {ReferencedHashes | undefined} referencedHashes
+ * @property {Hashes} hashes
  */
 
 /**
- * @typedef {Object} CompilationHooks
+ * @typedef {object} CompilationHooks
  * @property {SyncBailHook<[Buffer[], string], string>} updateHash
  */
 
@@ -115,6 +128,11 @@ class RealContentHashPlugin {
 		return hooks;
 	}
 
+	/**
+	 * @param {object} options options object
+	 * @param {string | Hash} options.hashFunction the hash function to use
+	 * @param {string} options.hashDigest the hash digest to use
+	 */
 	constructor({ hashFunction, hashDigest }) {
 		this._hashFunction = hashFunction;
 		this._hashDigest = hashDigest;
@@ -143,27 +161,25 @@ class RealContentHashPlugin {
 					const assets = compilation.getAssets();
 					/** @type {AssetInfoForRealContentHash[]} */
 					const assetsWithInfo = [];
+					/** @type {Map<string, [AssetInfoForRealContentHash]>} */
 					const hashToAssets = new Map();
 					for (const { source, info, name } of assets) {
 						const cachedSource = toCachedSource(source);
-						const content = cachedSource.source();
-						/** @type {Set<string>} */
+						const content = /** @type {string} */ (cachedSource.source());
+						/** @type {Hashes} */
 						const hashes = new Set();
 						addToList(info.contenthash, hashes);
+						/** @type {AssetInfoForRealContentHash} */
 						const data = {
 							name,
 							info,
 							source: cachedSource,
-							/** @type {RawSource | undefined} */
 							newSource: undefined,
-							/** @type {RawSource | undefined} */
 							newSourceWithoutOwn: undefined,
 							content,
-							/** @type {Set<string>} */
 							ownHashes: undefined,
 							contentComputePromise: undefined,
 							contentComputeWithoutOwnPromise: undefined,
-							/** @type {Set<string>} */
 							referencedHashes: undefined,
 							hashes
 						};
@@ -197,7 +213,7 @@ class RealContentHashPlugin {
 							[asset.referencedHashes, asset.ownHashes] =
 								await cacheAnalyse.providePromise(name, etag, () => {
 									const referencedHashes = new Set();
-									let ownHashes = new Set();
+									const ownHashes = new Set();
 									const inContent = content.match(hashRegExp);
 									if (inContent) {
 										for (const hash of inContent) {
@@ -212,11 +228,17 @@ class RealContentHashPlugin {
 								});
 						})
 					);
+					/**
+					 * @param {string} hash the hash
+					 * @returns {undefined | ReferencedHashes} the referenced hashes
+					 */
 					const getDependencies = hash => {
 						const assets = hashToAssets.get(hash);
 						if (!assets) {
 							const referencingAssets = assetsWithInfo.filter(asset =>
-								asset.referencedHashes.has(hash)
+								/** @type {ReferencedHashes} */ (asset.referencedHashes).has(
+									hash
+								)
 							);
 							const err = new WebpackError(`RealContentHashPlugin
 Some kind of unexpected caching problem occurred.
@@ -232,27 +254,40 @@ ${referencingAssets
 	})
 	.join("\n")}`);
 							compilation.errors.push(err);
-							return undefined;
+							return;
 						}
 						const hashes = new Set();
 						for (const { referencedHashes, ownHashes } of assets) {
-							if (!ownHashes.has(hash)) {
-								for (const hash of ownHashes) {
+							if (!(/** @type {OwnHashes} */ (ownHashes).has(hash))) {
+								for (const hash of /** @type {OwnHashes} */ (ownHashes)) {
 									hashes.add(hash);
 								}
 							}
-							for (const hash of referencedHashes) {
+							for (const hash of /** @type {ReferencedHashes} */ (
+								referencedHashes
+							)) {
 								hashes.add(hash);
 							}
 						}
 						return hashes;
 					};
+					/**
+					 * @param {string} hash the hash
+					 * @returns {string} the hash info
+					 */
 					const hashInfo = hash => {
 						const assets = hashToAssets.get(hash);
-						return `${hash} (${Array.from(assets, a => a.name)})`;
+						return `${hash} (${Array.from(
+							/** @type {AssetInfoForRealContentHash[]} */ (assets),
+							a => a.name
+						)})`;
 					};
 					const hashesInOrder = new Set();
 					for (const hash of hashToAssets.keys()) {
+						/**
+						 * @param {string} hash the hash
+						 * @param {Set<string>} stack stack of hashes
+						 */
 						const add = (hash, stack) => {
 							const deps = getDependencies(hash);
 							if (!deps) return;
@@ -276,21 +311,31 @@ ${referencingAssets
 						add(hash, new Set());
 					}
 					const hashToNewHash = new Map();
+					/**
+					 * @param {AssetInfoForRealContentHash} asset asset info
+					 * @returns {Etag} etag
+					 */
 					const getEtag = asset =>
 						cacheGenerate.mergeEtags(
 							cacheGenerate.getLazyHashedEtag(asset.source),
-							Array.from(asset.referencedHashes, hash =>
-								hashToNewHash.get(hash)
+							Array.from(
+								/** @type {ReferencedHashes} */ (asset.referencedHashes),
+								hash => hashToNewHash.get(hash)
 							).join("|")
 						);
+					/**
+					 * @param {AssetInfoForRealContentHash} asset asset info
+					 * @returns {Promise<void>}
+					 */
 					const computeNewContent = asset => {
 						if (asset.contentComputePromise) return asset.contentComputePromise;
 						return (asset.contentComputePromise = (async () => {
 							if (
-								asset.ownHashes.size > 0 ||
-								Array.from(asset.referencedHashes).some(
-									hash => hashToNewHash.get(hash) !== hash
-								)
+								/** @type {OwnHashes} */ (asset.ownHashes).size > 0 ||
+								Array.from(
+									/** @type {ReferencedHashes} */
+									(asset.referencedHashes)
+								).some(hash => hashToNewHash.get(hash) !== hash)
 							) {
 								const identifier = asset.name;
 								const etag = getEtag(asset);
@@ -307,17 +352,22 @@ ${referencingAssets
 							}
 						})());
 					};
+					/**
+					 * @param {AssetInfoForRealContentHash} asset asset info
+					 * @returns {Promise<void>}
+					 */
 					const computeNewContentWithoutOwn = asset => {
 						if (asset.contentComputeWithoutOwnPromise)
 							return asset.contentComputeWithoutOwnPromise;
 						return (asset.contentComputeWithoutOwnPromise = (async () => {
 							if (
-								asset.ownHashes.size > 0 ||
-								Array.from(asset.referencedHashes).some(
-									hash => hashToNewHash.get(hash) !== hash
-								)
+								/** @type {OwnHashes} */ (asset.ownHashes).size > 0 ||
+								Array.from(
+									/** @type {ReferencedHashes} */
+									(asset.referencedHashes)
+								).some(hash => hashToNewHash.get(hash) !== hash)
 							) {
-								const identifier = asset.name + "|without-own";
+								const identifier = `${asset.name}|without-own`;
 								const etag = getEtag(asset);
 								asset.newSourceWithoutOwn = await cacheGenerate.providePromise(
 									identifier,
@@ -326,7 +376,9 @@ ${referencingAssets
 										const newContent = asset.content.replace(
 											hashRegExp,
 											hash => {
-												if (asset.ownHashes.has(hash)) {
+												if (
+													/** @type {OwnHashes} */ (asset.ownHashes).has(hash)
+												) {
 													return "";
 												}
 												return hashToNewHash.get(hash);
@@ -340,29 +392,33 @@ ${referencingAssets
 					};
 					const comparator = compareSelect(a => a.name, compareStrings);
 					for (const oldHash of hashesInOrder) {
-						const assets = hashToAssets.get(oldHash);
+						const assets =
+							/** @type {AssetInfoForRealContentHash[]} */
+							(hashToAssets.get(oldHash));
 						assets.sort(comparator);
-						const hash = createHash(this._hashFunction);
 						await Promise.all(
 							assets.map(asset =>
-								asset.ownHashes.has(oldHash)
+								/** @type {OwnHashes} */ (asset.ownHashes).has(oldHash)
 									? computeNewContentWithoutOwn(asset)
 									: computeNewContent(asset)
 							)
 						);
 						const assetsContent = mapAndDeduplicateBuffers(assets, asset => {
-							if (asset.ownHashes.has(oldHash)) {
+							if (/** @type {OwnHashes} */ (asset.ownHashes).has(oldHash)) {
 								return asset.newSourceWithoutOwn
 									? asset.newSourceWithoutOwn.buffer()
 									: asset.source.buffer();
-							} else {
-								return asset.newSource
-									? asset.newSource.buffer()
-									: asset.source.buffer();
 							}
+							return asset.newSource
+								? asset.newSource.buffer()
+								: asset.source.buffer();
 						});
 						let newHash = hooks.updateHash.call(assetsContent, oldHash);
 						if (!newHash) {
+							const hash = createHash(this._hashFunction);
+							if (compilation.outputOptions.hashSalt) {
+								hash.update(compilation.outputOptions.hashSalt);
+							}
 							for (const content of assetsContent) {
 								hash.update(content);
 							}

package/lib/optimize/RemoveParentModulesPlugin.js

@@ -6,10 +6,58 @@
 "use strict";
 
 const { STAGE_BASIC } = require("../OptimizationStages");
-const Queue = require("../util/Queue");
-const { intersect } = require("../util/SetHelpers");
 
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGroup")} ChunkGroup */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
+
+/**
+ * Intersects multiple masks represented as bigints
+ * @param {bigint[]} masks The module masks to intersect
+ * @returns {bigint} The intersection of all masks
+ */
+function intersectMasks(masks) {
+	let result = masks[0];
+	for (let i = masks.length - 1; i >= 1; i--) {
+		result &= masks[i];
+	}
+	return result;
+}
+
+const ZERO_BIGINT = BigInt(0);
+const ONE_BIGINT = BigInt(1);
+const THIRTY_TWO_BIGINT = BigInt(32);
+
+/**
+ * Parses the module mask and returns the modules represented by it
+ * @param {bigint} mask the module mask
+ * @param {Module[]} ordinalModules the modules in the order they were added to the mask (LSB is index 0)
+ * @returns {Generator<Module>} the modules represented by the mask
+ */
+function* getModulesFromMask(mask, ordinalModules) {
+	let offset = 31;
+	while (mask !== ZERO_BIGINT) {
+		// Consider the last 32 bits, since that's what Math.clz32 can handle
+		let last32 = Number(BigInt.asUintN(32, mask));
+		while (last32 > 0) {
+			const last = Math.clz32(last32);
+			// The number of trailing zeros is the number trimmed off the input mask + 31 - the number of leading zeros
+			// The 32 is baked into the initial value of offset
+			const moduleIndex = offset - last;
+			// The number of trailing zeros is the index into the array generated by getOrCreateModuleMask
+			const module = ordinalModules[moduleIndex];
+			yield module;
+			// Remove the matched module from the mask
+			// Since we can only count leading zeros, not trailing, we can't just downshift the mask
+			last32 &= ~(1 << (31 - last));
+		}
+
+		// Remove the processed chunk from the mask
+		mask >>= THIRTY_TWO_BIGINT;
+		offset += 32;
+	}
+}
 
 class RemoveParentModulesPlugin {
 	/**
@@ -18,94 +66,129 @@ class RemoveParentModulesPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap("RemoveParentModulesPlugin", compilation => {
+			/**
+			 * @param {Iterable<Chunk>} chunks the chunks
+			 * @param {ChunkGroup[]} chunkGroups the chunk groups
+			 */
 			const handler = (chunks, chunkGroups) => {
 				const chunkGraph = compilation.chunkGraph;
-				const queue = new Queue();
+				const queue = new Set();
 				const availableModulesMap = new WeakMap();
 
+				let nextModuleMask = ONE_BIGINT;
+				const maskByModule = new WeakMap();
+				/** @type {Module[]} */
+				const ordinalModules = [];
+
+				/**
+				 * Gets or creates a unique mask for a module
+				 * @param {Module} mod the module to get the mask for
+				 * @returns {bigint} the module mask to uniquely identify the module
+				 */
+				const getOrCreateModuleMask = mod => {
+					let id = maskByModule.get(mod);
+					if (id === undefined) {
+						id = nextModuleMask;
+						ordinalModules.push(mod);
+						maskByModule.set(mod, id);
+						nextModuleMask <<= ONE_BIGINT;
+					}
+					return id;
+				};
+
+				// Initialize masks by chunk and by chunk group for quicker comparisons
+				const chunkMasks = new WeakMap();
+				for (const chunk of chunks) {
+					let mask = ZERO_BIGINT;
+					for (const m of chunkGraph.getChunkModulesIterable(chunk)) {
+						const id = getOrCreateModuleMask(m);
+						mask |= id;
+					}
+					chunkMasks.set(chunk, mask);
+				}
+
+				const chunkGroupMasks = new WeakMap();
+				for (const chunkGroup of chunkGroups) {
+					let mask = ZERO_BIGINT;
+					for (const chunk of chunkGroup.chunks) {
+						const chunkMask = chunkMasks.get(chunk);
+						if (chunkMask !== undefined) {
+							mask |= chunkMask;
+						}
+					}
+					chunkGroupMasks.set(chunkGroup, mask);
+				}
+
 				for (const chunkGroup of compilation.entrypoints.values()) {
 					// initialize available modules for chunks without parents
-					availableModulesMap.set(chunkGroup, new Set());
+					availableModulesMap.set(chunkGroup, ZERO_BIGINT);
 					for (const child of chunkGroup.childrenIterable) {
-						queue.enqueue(child);
+						queue.add(child);
 					}
 				}
 				for (const chunkGroup of compilation.asyncEntrypoints) {
 					// initialize available modules for chunks without parents
-					availableModulesMap.set(chunkGroup, new Set());
+					availableModulesMap.set(chunkGroup, ZERO_BIGINT);
 					for (const child of chunkGroup.childrenIterable) {
-						queue.enqueue(child);
+						queue.add(child);
 					}
 				}
 
-				while (queue.length > 0) {
-					const chunkGroup = queue.dequeue();
-					let availableModules = availableModulesMap.get(chunkGroup);
+				for (const chunkGroup of queue) {
+					let availableModulesMask = availableModulesMap.get(chunkGroup);
 					let changed = false;
 					for (const parent of chunkGroup.parentsIterable) {
 						const availableModulesInParent = availableModulesMap.get(parent);
 						if (availableModulesInParent !== undefined) {
+							const parentMask =
+								availableModulesInParent | chunkGroupMasks.get(parent);
 							// If we know the available modules in parent: process these
-							if (availableModules === undefined) {
+							if (availableModulesMask === undefined) {
 								// if we have not own info yet: create new entry
-								availableModules = new Set(availableModulesInParent);
-								for (const chunk of parent.chunks) {
-									for (const m of chunkGraph.getChunkModulesIterable(chunk)) {
-										availableModules.add(m);
-									}
-								}
-								availableModulesMap.set(chunkGroup, availableModules);
+								availableModulesMask = parentMask;
 								changed = true;
 							} else {
-								for (const m of availableModules) {
-									if (
-										!chunkGraph.isModuleInChunkGroup(m, parent) &&
-										!availableModulesInParent.has(m)
-									) {
-										availableModules.delete(m);
-										changed = true;
-									}
+								const newMask = availableModulesMask & parentMask;
+								if (newMask !== availableModulesMask) {
+									changed = true;
+									availableModulesMask = newMask;
 								}
 							}
 						}
 					}
+
 					if (changed) {
+						availableModulesMap.set(chunkGroup, availableModulesMask);
 						// if something changed: enqueue our children
 						for (const child of chunkGroup.childrenIterable) {
-							queue.enqueue(child);
+							// Push the child to the end of the queue
+							queue.delete(child);
+							queue.add(child);
 						}
 					}
 				}
 
 				// now we have available modules for every chunk
 				for (const chunk of chunks) {
+					const chunkMask = chunkMasks.get(chunk);
+					if (chunkMask === undefined) continue; // No info about this chunk
+
 					const availableModulesSets = Array.from(
 						chunk.groupsIterable,
 						chunkGroup => availableModulesMap.get(chunkGroup)
 					);
-					if (availableModulesSets.some(s => s === undefined)) continue; // No info about this chunk group
-					const availableModules =
-						availableModulesSets.length === 1
-							? availableModulesSets[0]
-							: intersect(availableModulesSets);
-					const numberOfModules = chunkGraph.getNumberOfChunkModules(chunk);
-					const toRemove = new Set();
-					if (numberOfModules < availableModules.size) {
-						for (const m of chunkGraph.getChunkModulesIterable(chunk)) {
-							if (availableModules.has(m)) {
-								toRemove.add(m);
-							}
-						}
-					} else {
-						for (const m of availableModules) {
-							if (chunkGraph.isModuleInChunk(m, chunk)) {
-								toRemove.add(m);
-							}
+					if (availableModulesSets.includes(undefined)) continue; // No info about this chunk group
+
+					const availableModulesMask = intersectMasks(availableModulesSets);
+					const toRemoveMask = chunkMask & availableModulesMask;
+					if (toRemoveMask !== ZERO_BIGINT) {
+						for (const module of getModulesFromMask(
+							toRemoveMask,
+							ordinalModules
+						)) {
+							chunkGraph.disconnectChunkAndModule(chunk, module);
 						}
 					}
-					for (const module of toRemove) {
-						chunkGraph.disconnectChunkAndModule(chunk, module);
-					}
 				}
 			};
 			compilation.hooks.optimizeChunks.tap(

package/lib/optimize/RuntimeChunkPlugin.js

@@ -5,11 +5,20 @@
 
 "use strict";
 
+/** @typedef {import("../Compilation").EntryData} EntryData */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Entrypoint")} Entrypoint */
 
 class RuntimeChunkPlugin {
+	/**
+	 * @param {{ name?: (entrypoint: { name: string }) => string }} options options
+	 */
 	constructor(options) {
 		this.options = {
+			/**
+			 * @param {Entrypoint} entrypoint entrypoint name
+			 * @returns {string} runtime chunk name
+			 */
 			name: entrypoint => `runtime~${entrypoint.name}`,
 			...options
 		};
@@ -26,10 +35,14 @@ class RuntimeChunkPlugin {
 				"RuntimeChunkPlugin",
 				(_, { name: entryName }) => {
 					if (entryName === undefined) return;
-					const data = compilation.entries.get(entryName);
+					const data =
+						/** @type {EntryData} */
+						(compilation.entries.get(entryName));
 					if (data.options.runtime === undefined && !data.options.dependOn) {
 						// Determine runtime chunk name
-						let name = this.options.name;
+						let name =
+							/** @type {string | ((entrypoint: { name: string }) => string)} */
+							(this.options.name);
 						if (typeof name === "function") {
 							name = name({ name: entryName });
 						}