webpack 5.108.4 → 5.109.1

package/lib/util/AsyncQueue.js

@@ -159,6 +159,11 @@ class AsyncQueue {
 	 */
 	add(item, callback) {
 		if (this._stopped) return callback(new WebpackError("Queue was stopped"));
+		// skip async hook dispatch when unused — this runs per module × queue
+		if (!this.hooks.beforeAdd.isUsed()) {
+			this._add(item, callback);
+			return;
+		}
 		this.hooks.beforeAdd.callAsync(item, (err) => {
 			if (err) {
 				callback(
@@ -166,42 +171,52 @@ class AsyncQueue {
 				);
 				return;
 			}
-			const key = this._getKey(item);
-			const entry = this._entries.get(key);
-			if (entry !== undefined) {
-				if (entry.state === DONE_STATE) {
-					if (inHandleResult++ > 3) {
-						process.nextTick(() => callback(entry.error, entry.result));
-					} else {
-						callback(entry.error, entry.result);
-					}
-					inHandleResult--;
-				} else if (entry.callbacks === undefined) {
-					entry.callbacks = [callback];
+			this._add(item, callback);
+		});
+	}
+
+	/**
+	 * Processes the provided item, after the beforeAdd hook.
+	 * @param {T} item an item
+	 * @param {Callback<R>} callback callback function
+	 * @returns {void}
+	 */
+	_add(item, callback) {
+		const key = this._getKey(item);
+		const entry = this._entries.get(key);
+		if (entry !== undefined) {
+			if (entry.state === DONE_STATE) {
+				if (inHandleResult++ > 3) {
+					process.nextTick(() => callback(entry.error, entry.result));
 				} else {
-					entry.callbacks.push(callback);
+					callback(entry.error, entry.result);
 				}
-				return;
-			}
-			const newEntry = new AsyncQueueEntry(item, callback);
-			if (this._stopped) {
-				this.hooks.added.call(item);
-				this._root._activeTasks++;
-				process.nextTick(() =>
-					this._handleResult(newEntry, new WebpackError("Queue was stopped"))
-				);
+				inHandleResult--;
+			} else if (entry.callbacks === undefined) {
+				entry.callbacks = [callback];
 			} else {
-				this._entries.set(key, newEntry);
-				this._queued.enqueue(newEntry);
-				const root = this._root;
-				root._needProcessing = true;
-				if (root._willEnsureProcessing === false) {
-					root._willEnsureProcessing = true;
-					setImmediate(root._ensureProcessing);
-				}
-				this.hooks.added.call(item);
+				entry.callbacks.push(callback);
 			}
-		});
+			return;
+		}
+		const newEntry = new AsyncQueueEntry(item, callback);
+		if (this._stopped) {
+			this.hooks.added.call(item);
+			this._root._activeTasks++;
+			process.nextTick(() =>
+				this._handleResult(newEntry, new WebpackError("Queue was stopped"))
+			);
+		} else {
+			this._entries.set(key, newEntry);
+			this._queued.enqueue(newEntry);
+			const root = this._root;
+			root._needProcessing = true;
+			if (root._willEnsureProcessing === false) {
+				root._willEnsureProcessing = true;
+				setImmediate(root._ensureProcessing);
+			}
+			this.hooks.added.call(item);
+		}
 	}
 
 	/**
@@ -357,6 +372,11 @@ class AsyncQueue {
 	 * @returns {void}
 	 */
 	_startProcessing(entry) {
+		// skip async hook dispatch when unused — this runs per module × queue
+		if (!this.hooks.beforeStart.isUsed()) {
+			this._startProcessing2(entry);
+			return;
+		}
 		this.hooks.beforeStart.callAsync(entry.item, (err) => {
 			if (err) {
 				this._handleResult(
@@ -365,20 +385,29 @@ class AsyncQueue {
 				);
 				return;
 			}
-			let inCallback = false;
-			try {
-				this._processor(entry.item, (e, r) => {
-					inCallback = true;
-					this._handleResult(entry, e, r);
-				});
-			} catch (err) {
-				if (inCallback) throw err;
-				this._handleResult(entry, /** @type {WebpackError} */ (err), null);
-			}
-			this.hooks.started.call(entry.item);
+			this._startProcessing2(entry);
 		});
 	}
 
+	/**
+	 * Processes the provided entry, after the beforeStart hook.
+	 * @param {AsyncQueueEntry<T, K, R>} entry the entry
+	 * @returns {void}
+	 */
+	_startProcessing2(entry) {
+		let inCallback = false;
+		try {
+			this._processor(entry.item, (e, r) => {
+				inCallback = true;
+				this._handleResult(entry, e, r);
+			});
+		} catch (err) {
+			if (inCallback) throw err;
+			this._handleResult(entry, /** @type {WebpackError} */ (err), null);
+		}
+		this.hooks.started.call(entry.item);
+	}
+
 	/**
 	 * Processes the provided entry.
 	 * @param {AsyncQueueEntry<T, K, R>} entry the entry
@@ -387,45 +416,66 @@ class AsyncQueue {
 	 * @returns {void}
 	 */
 	_handleResult(entry, err, result) {
+		// skip async hook dispatch when unused — this runs per module × queue
+		if (!this.hooks.result.isUsed()) {
+			this._handleResult2(entry, err, result);
+			return;
+		}
 		this.hooks.result.callAsync(entry.item, err, result, (hookError) => {
-			const error = hookError
-				? makeWebpackError(hookError, `AsyncQueue(${this._name}).hooks.result`)
-				: err;
-
-			const callback = /** @type {Callback<R>} */ (entry.callback);
-			const callbacks = entry.callbacks;
-			entry.state = DONE_STATE;
-			entry.callback = undefined;
-			entry.callbacks = undefined;
-			entry.result = result;
-			entry.error = error;
+			this._handleResult2(
+				entry,
+				hookError
+					? makeWebpackError(
+							hookError,
+							`AsyncQueue(${this._name}).hooks.result`
+						)
+					: err,
+				result
+			);
+		});
+	}
 
-			const root = this._root;
-			root._activeTasks--;
-			if (root._willEnsureProcessing === false && root._needProcessing) {
-				root._willEnsureProcessing = true;
-				setImmediate(root._ensureProcessing);
-			}
+	/**
+	 * Finalizes the provided entry, after the result hook.
+	 * @param {AsyncQueueEntry<T, K, R>} entry the entry
+	 * @param {(WebpackError | null)=} error error, if any
+	 * @param {(R | null)=} result result, if any
+	 * @returns {void}
+	 */
+	_handleResult2(entry, error, result) {
+		const callback = /** @type {Callback<R>} */ (entry.callback);
+		const callbacks = entry.callbacks;
+		entry.state = DONE_STATE;
+		entry.callback = undefined;
+		entry.callbacks = undefined;
+		entry.result = result;
+		entry.error = error;
 
-			if (inHandleResult++ > 3) {
-				process.nextTick(() => {
-					callback(error, result);
-					if (callbacks !== undefined) {
-						for (const callback of callbacks) {
-							callback(error, result);
-						}
-					}
-				});
-			} else {
+		const root = this._root;
+		root._activeTasks--;
+		if (root._willEnsureProcessing === false && root._needProcessing) {
+			root._willEnsureProcessing = true;
+			setImmediate(root._ensureProcessing);
+		}
+
+		if (inHandleResult++ > 3) {
+			process.nextTick(() => {
 				callback(error, result);
 				if (callbacks !== undefined) {
 					for (const callback of callbacks) {
 						callback(error, result);
 					}
 				}
+			});
+		} else {
+			callback(error, result);
+			if (callbacks !== undefined) {
+				for (const callback of callbacks) {
+					callback(error, result);
+				}
 			}
-			inHandleResult--;
-		});
+		}
+		inHandleResult--;
 	}
 
 	clear() {

package/lib/util/SetHelpers.js

@@ -41,7 +41,7 @@ const intersect = (sets) => {
  * @template T
  * @param {Set<T>} bigSet a Set which contains the original elements to compare against
  * @param {Set<T>} smallSet the set whose elements might be contained inside of bigSet
- * @returns {boolean} returns true if smallSet contains all elements inside of the bigSet
+ * @returns {boolean} returns true if bigSet contains all elements inside of smallSet
  */
 const isSubset = (bigSet, smallSet) => {
 	if (bigSet.size < smallSet.size) return false;

package/lib/util/StackedMap.js

@@ -41,21 +41,24 @@ const extractPair = (pair) => {
 
 /**
  * Layered map that supports child scopes while memoizing lookups from parent
- * scopes into the current layer.
+ * scopes. Layers form a linked parent chain, so `createChild` is O(1) instead
+ * of copying a layer array per scope. A layer's `Map` is only allocated on its
+ * first own write, and lookup results are memoized into the nearest
+ * `Map`-bearing layer of the walk — read-only layers (most block scopes) stay
+ * allocation-free and share their parent's memoized entries.
  * @template K
  * @template V
  */
 class StackedMap {
 	/**
-	 * Creates a new map layer on top of an optional parent stack.
-	 * @param {Map<K, InternalCell<V>>[]=} parentStack an optional parent
+	 * Creates a new map layer on top of an optional parent.
+	 * @param {StackedMap<K, V>=} parent an optional parent map
 	 */
-	constructor(parentStack) {
-		/** @type {Map<K, InternalCell<V>>} */
-		this.map = new Map();
-		/** @type {Map<K, InternalCell<V>>[]} */
-		this.stack = parentStack === undefined ? [] : [...parentStack];
-		this.stack.push(this.map);
+	constructor(parent) {
+		/** @type {Map<K, InternalCell<V>> | undefined} */
+		this.map = undefined;
+		/** @type {StackedMap<K, V> | undefined} */
+		this.parent = parent;
 	}
 
 	/**
@@ -66,7 +69,10 @@ class StackedMap {
 	 * @returns {void}
 	 */
 	set(item, value) {
-		this.map.set(item, value === undefined ? UNDEFINED_MARKER : value);
+		(this.map || (this.map = new Map())).set(
+			item,
+			value === undefined ? UNDEFINED_MARKER : value
+		);
 	}
 
 	/**
@@ -76,80 +82,145 @@ class StackedMap {
 	 * @returns {void}
 	 */
 	delete(item) {
-		if (this.stack.length > 1) {
-			this.map.set(item, TOMBSTONE);
-		} else {
+		if (this.parent !== undefined) {
+			(this.map || (this.map = new Map())).set(item, TOMBSTONE);
+		} else if (this.map !== undefined) {
 			this.map.delete(item);
 		}
 	}
 
 	/**
 	 * Checks whether a key exists in the current scope chain, caching any parent
-	 * lookup result in the current layer.
+	 * lookup result in the nearest `Map`-bearing layer.
 	 * @param {K} item the item to test
 	 * @returns {boolean} true if the item exists in this set
 	 */
 	has(item) {
-		const topValue = this.map.get(item);
-		if (topValue !== undefined) {
-			return topValue !== TOMBSTONE;
+		const own = this.map;
+		if (own !== undefined) {
+			const topValue = own.get(item);
+			if (topValue !== undefined) {
+				return topValue !== TOMBSTONE;
+			}
 		}
-		if (this.stack.length > 1) {
-			for (let i = this.stack.length - 2; i >= 0; i--) {
-				const value = this.stack[i].get(item);
+		/** @type {StackedMap<K, V> | undefined} */
+		let memoTarget = own !== undefined ? this : undefined;
+		/** @type {StackedMap<K, V> | undefined} */
+		let current = this.parent;
+		while (current !== undefined) {
+			const map = current.map;
+			if (map !== undefined) {
+				const value = map.get(item);
 				if (value !== undefined) {
-					this.map.set(item, value);
+					if (memoTarget !== undefined) {
+						/** @type {Map<K, InternalCell<V>>} */ (memoTarget.map).set(
+							item,
+							value
+						);
+					}
 					return value !== TOMBSTONE;
 				}
+				if (memoTarget === undefined) memoTarget = current;
 			}
-			this.map.set(item, TOMBSTONE);
+			current = current.parent;
+		}
+		if (memoTarget !== undefined) {
+			/** @type {Map<K, InternalCell<V>>} */ (memoTarget.map).set(
+				item,
+				TOMBSTONE
+			);
 		}
 		return false;
 	}
 
 	/**
 	 * Returns the visible value for a key, caching parent hits and misses in the
-	 * current layer.
+	 * nearest `Map`-bearing layer so repeated lookups (from this layer or any
+	 * sibling below that layer) answer with a single probe.
 	 * @param {K} item the key of the element to return
 	 * @returns {Cell<V>} the value of the element
 	 */
 	get(item) {
-		const topValue = this.map.get(item);
-		if (topValue !== undefined) {
-			return topValue === TOMBSTONE || topValue === UNDEFINED_MARKER
-				? undefined
-				: topValue;
+		const own = this.map;
+		if (own !== undefined) {
+			const topValue = own.get(item);
+			if (topValue !== undefined) {
+				return topValue === TOMBSTONE || topValue === UNDEFINED_MARKER
+					? undefined
+					: topValue;
+			}
 		}
-		if (this.stack.length > 1) {
-			for (let i = this.stack.length - 2; i >= 0; i--) {
-				const value = this.stack[i].get(item);
+		/** @type {StackedMap<K, V> | undefined} */
+		let memoTarget = own !== undefined ? this : undefined;
+		/** @type {StackedMap<K, V> | undefined} */
+		let current = this.parent;
+		while (current !== undefined) {
+			const map = current.map;
+			if (map !== undefined) {
+				const value = map.get(item);
 				if (value !== undefined) {
-					this.map.set(item, value);
+					if (memoTarget !== undefined) {
+						/** @type {Map<K, InternalCell<V>>} */ (memoTarget.map).set(
+							item,
+							value
+						);
+					}
 					return value === TOMBSTONE || value === UNDEFINED_MARKER
 						? undefined
 						: value;
 				}
+				if (memoTarget === undefined) memoTarget = current;
 			}
-			this.map.set(item, TOMBSTONE);
+			current = current.parent;
+		}
+		if (memoTarget !== undefined) {
+			/** @type {Map<K, InternalCell<V>>} */ (memoTarget.map).set(
+				item,
+				TOMBSTONE
+			);
 		}
 	}
 
 	/**
-	 * Collapses the stacked layers into a single concrete map.
+	 * Collapses the parent chain into a single concrete map.
 	 */
 	_compress() {
-		if (this.stack.length === 1) return;
-		this.map = new Map();
-		for (const data of this.stack) {
-			for (const pair of data) {
-				if (pair[1] === TOMBSTONE) {
-					this.map.delete(pair[0]);
-				} else {
-					this.map.set(pair[0], pair[1]);
+		if (this.parent === undefined) {
+			const map = this.map;
+			if (map === undefined) {
+				this.map = new Map();
+				return;
+			}
+			// a parent-less layer holds tombstones only as memoized misses
+			// (deletes remove outright) — drop them from the visible view
+			for (const pair of map) {
+				if (pair[1] === TOMBSTONE) map.delete(pair[0]);
+			}
+			return;
+		}
+		/** @type {StackedMap<K, V>[]} */
+		const layers = [];
+		/** @type {StackedMap<K, V> | undefined} */
+		let current = this;
+		do {
+			layers.push(current);
+			current = current.parent;
+		} while (current !== undefined);
+		const map = new Map();
+		for (let i = layers.length - 1; i >= 0; i--) {
+			const layerMap = layers[i].map;
+			if (layerMap !== undefined) {
+				for (const pair of layerMap) {
+					if (pair[1] === TOMBSTONE) {
+						map.delete(pair[0]);
+					} else {
+						map.set(pair[0], pair[1]);
+					}
 				}
 			}
 		}
-		this.stack = [this.map];
+		this.map = map;
+		this.parent = undefined;
 	}
 
 	/**
@@ -158,7 +229,7 @@ class StackedMap {
 	 */
 	asArray() {
 		this._compress();
-		return [...this.map.keys()];
+		return [.../** @type {Map<K, InternalCell<V>>} */ (this.map).keys()];
 	}
 
 	/**
@@ -167,7 +238,7 @@ class StackedMap {
 	 */
 	asSet() {
 		this._compress();
-		return new Set(this.map.keys());
+		return new Set(/** @type {Map<K, InternalCell<V>>} */ (this.map).keys());
 	}
 
 	/**
@@ -176,7 +247,10 @@ class StackedMap {
 	 */
 	asPairArray() {
 		this._compress();
-		return Array.from(this.map.entries(), extractPair);
+		return Array.from(
+			/** @type {Map<K, InternalCell<V>>} */ (this.map).entries(),
+			extractPair
+		);
 	}
 
 	/**
@@ -193,7 +267,7 @@ class StackedMap {
 	 */
 	get size() {
 		this._compress();
-		return this.map.size;
+		return /** @type {Map<K, InternalCell<V>>} */ (this.map).size;
 	}
 
 	/**
@@ -202,7 +276,7 @@ class StackedMap {
 	 * @returns {StackedMap<K, V>} child map
 	 */
 	createChild() {
-		return new StackedMap(this.stack);
+		return new StackedMap(this);
 	}
 }
 

package/lib/util/binarySearchBounds.js

@@ -128,9 +128,9 @@ const fns = {
  * const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
  *
  * // Find the index of the first element greater than 5
- * const index1 = gt(arr, 5); // index1 === 3
+ * const index1 = gt(arr, 5); // index1 === 5
  *
- * // Find the index of the first element less than or equal to 5
+ * // Find the index of the last element less than or equal to 5
  * const index2 = le(arr, 5); // index2 === 4
  * ```
  */

package/lib/util/concatenate.js

@@ -25,11 +25,14 @@ const NAMESPACE_OBJECT_EXPORT = "__WEBPACK_NAMESPACE_OBJECT__";
 const getAllReferences = (variable) => {
 	let set = variable.references;
 	// Look for inner scope variables too (like in class Foo { t() { Foo } })
-	const identifiers = new Set(variable.identifiers);
+	// identifiers is tiny (usually 1 declaration) — indexOf beats a Set here
+	const identifiers = variable.identifiers;
 	for (const scope of variable.scope.childScopes) {
 		for (const innerVar of scope.variables) {
-			if (innerVar.identifiers.some((id) => identifiers.has(id))) {
-				set = [...set, ...innerVar.references];
+			if (innerVar.identifiers.some((id) => identifiers.includes(id))) {
+				// copy-on-write to keep the common no-match case allocation-free
+				if (set === variable.references) set = [...set];
+				for (const ref of innerVar.references) set.push(ref);
 				break;
 			}
 		}
@@ -113,6 +116,32 @@ const getPathInAst = (ast, node) => {
 	}
 };
 
+/** @type {Map<string, string[]>} */
+const splittedInfoCache = new Map();
+
+/**
+ * Returns path segments of the cleaned extra info.
+ * @param {string} extraInfo extra info
+ * @returns {string[]} cleaned path segments
+ */
+const getSplittedInfo = (extraInfo) => {
+	let splittedInfo = splittedInfoCache.get(extraInfo);
+	if (splittedInfo === undefined) {
+		// bound the cache — extraInfo repeats for every renamed binding of a
+		// module, but distinct values grow with project size
+		if (splittedInfoCache.size >= 4096) splittedInfoCache.clear();
+		// Remove uncool stuff
+		splittedInfo = extraInfo
+			.replace(
+				/\.+\/|(?:\/index)?\.[a-zA-Z0-9]{1,4}(?:$|\s|\?)|\s*\+\s*\d+\s*modules/g,
+				""
+			)
+			.split("/");
+		splittedInfoCache.set(extraInfo, splittedInfo);
+	}
+	return splittedInfo;
+};
+
 /**
  * Returns found new name.
  * @param {string} oldName old name
@@ -131,15 +160,9 @@ function findNewName(oldName, usedNamed1, usedNamed2, extraInfo) {
 		name = "namespaceObject";
 	}
 
-	// Remove uncool stuff
-	extraInfo = extraInfo.replace(
-		/\.+\/|(?:\/index)?\.[a-zA-Z0-9]{1,4}(?:$|\s|\?)|\s*\+\s*\d+\s*modules/g,
-		""
-	);
-
-	const splittedInfo = extraInfo.split("/");
-	while (splittedInfo.length) {
-		name = splittedInfo.pop() + (name ? `_${name}` : "");
+	const splittedInfo = getSplittedInfo(extraInfo);
+	for (let i = splittedInfo.length - 1; i >= 0; i--) {
+		name = splittedInfo[i] + (name ? `_${name}` : "");
 		const nameIdent = Template.toIdentifier(name);
 		if (
 			!usedNamed1.has(nameIdent) &&
@@ -149,15 +172,18 @@ function findNewName(oldName, usedNamed1, usedNamed2, extraInfo) {
 		}
 	}
 
+	// `_${i}` is identifier-safe, so escaping the base once is equivalent to
+	// escaping every candidate — avoids two regexes per collision
+	const nameIdent = Template.toIdentifier(name);
 	let i = 0;
-	let nameWithNumber = Template.toIdentifier(`${name}_${i}`);
+	let nameWithNumber = `${nameIdent}_${i}`;
 	while (
 		usedNamed1.has(nameWithNumber) ||
 		// eslint-disable-next-line no-unmodified-loop-condition
 		(usedNamed2 && usedNamed2.has(nameWithNumber))
 	) {
 		i++;
-		nameWithNumber = Template.toIdentifier(`${name}_${i}`);
+		nameWithNumber = `${nameIdent}_${i}`;
 	}
 	return nameWithNumber;
 }

package/lib/util/createHooksRegistry.js

@@ -17,11 +17,19 @@ const createHooksRegistry = (createHooks) => {
 	/** @type {WeakMap<import("../Compilation"), T>} */
 	const map = new WeakMap();
 	return (compilation) => {
-		const Compilation = getCompilation();
-		if (!(compilation instanceof Compilation)) {
-			throw new TypeError(
-				"The 'compilation' argument must be an instance of Compilation"
-			);
+		if (!(compilation instanceof getCompilation())) {
+			// a compilation from another webpack copy fails instanceof — match the class name
+			const candidate =
+				/** @type {{ constructor?: { name: string } } | null} */ (compilation);
+			if (
+				!candidate ||
+				!candidate.constructor ||
+				candidate.constructor.name !== "Compilation"
+			) {
+				throw new TypeError(
+					"The 'compilation' argument must be an instance of Compilation"
+				);
+			}
 		}
 		let hooks = map.get(compilation);
 		if (hooks === undefined) {

package/lib/util/dataURL.js

@@ -28,9 +28,9 @@ const decodeDataURI = (uri) => {
 	// CSS allows to use `data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg"><rect width="100%" height="100%" style="stroke: rgb(223,224,225); stroke-width: 2px; fill: none; stroke-dasharray: 6px 3px" /></svg>`
 	// so we return original body if we can't `decodeURIComponent`
 	try {
-		return Buffer.from(decodeURIComponent(body), "ascii");
+		return Buffer.from(decodeURIComponent(body), "utf8");
 	} catch (_) {
-		return Buffer.from(body, "ascii");
+		return Buffer.from(body, "utf8");
 	}
 };