webpack 5.108.3 → 5.109.0

package/lib/util/SourceProcessor.js

@@ -6,36 +6,41 @@
 
 /**
  * Babel-style visitor map keyed by a numeric node-type discriminator; a bucket
- * is a function (enter-only) or `{ enter?, exit? }`. `ctx.skipChildren()`
- * (enter only) stops the walker descending into the node's children.
- * @typedef {{ skipChildren(): void }} VisitorContext
- */
-/**
- * @template TNode
- * @typedef {(node: TNode, parent: TNode | null, ctx: VisitorContext) => void} VisitorFn
+ * is a function (enter-only) or `{ enter?, exit? }`.
+ *
+ * A visitor receives a single `path` argument (the Babel `path` shape): the
+ * language's AST accessor with the current position on it — `path.node`,
+ * `path.parent` (null at a root) — plus `path.skipChildren()` (enter only)
+ * to stop the walk descending, and every field-read method (which defaults
+ * to the current node). The path is one reused object rebound before each callback:
+ * it is only valid during the callback, and future per-node functionality
+ * lands on it without changing any visitor signature.
+ * @template TPath
+ * @typedef {(path: TPath) => void} VisitorFn
  */
 /**
- * @template TNode
- * @typedef {VisitorFn<TNode> | { enter?: VisitorFn<TNode>, exit?: VisitorFn<TNode> }} VisitorBucket
+ * @template TPath
+ * @typedef {VisitorFn<TPath> | { enter?: VisitorFn<TPath>, exit?: VisitorFn<TPath> }} VisitorBucket
  */
 /**
- * @template TNode
- * @typedef {{ [nodeType: number]: VisitorBucket<TNode> }} VisitorMap
+ * @template TPath
+ * @typedef {{ [nodeType: number]: VisitorBucket<TPath> }} VisitorMap
  */
 /**
- * @template TNode
- * @typedef {{ enter: VisitorFn<TNode>[], exit: VisitorFn<TNode>[] }} CompiledVisitorBucket
+ * @template TPath
+ * @typedef {{ enter: VisitorFn<TPath>[], exit: VisitorFn<TPath>[] }} CompiledVisitorBucket
  */
 /**
- * @template TNode
- * @typedef {CompiledVisitorBucket<TNode>[]} CompiledVisitorMap a sparse array indexed by node type
+ * @template TPath
+ * @typedef {CompiledVisitorBucket<TPath>[]} CompiledVisitorMap a sparse array indexed by node type
  */
 /**
  * A language grammar: parse `input` and fire the compiled visitors in source
- * order (the grammar owns tokenizing, parsing, and walking).
- * @template TNode
+ * order (the grammar owns tokenizing, parsing, walking — and the `path`
+ * object each visitor receives).
+ * @template TPath
  * @template TProcessOptions
- * @typedef {(input: string, visitors: CompiledVisitorMap<TNode>, options: TProcessOptions) => void} Grammar
+ * @typedef {(input: string, visitors: CompiledVisitorMap<TPath>, options: TProcessOptions) => void} Grammar
  */
 
 /**
@@ -44,28 +49,31 @@
  * binds its own grammar and node-type enum. Babel-style usage:
  *
  * ```
- * processor.use({ [NodeType.X]: (node) => {}, [NodeType.Y]: { enter, exit } });
+ * processor.use({ [NodeType.X]: (path) => {}, [NodeType.Y]: { enter, exit } });
  * processor.process(source);
  * ```
- * @template TNode
+ * @template TPath
  * @template [TProcessOptions=object]
  */
 class SourceProcessor {
 	/**
-	 * @param {Grammar<TNode, TProcessOptions>} grammar the grammar to drive over the source
+	 * @param {Grammar<TPath, TProcessOptions>} grammar the grammar to drive over the source
+	 * @param {TProcessOptions=} options default process options (e.g. `skip`) merged under each `process` call's own options
 	 */
-	constructor(grammar) {
-		/** @type {Grammar<TNode, TProcessOptions>} */
+	constructor(grammar, options) {
+		/** @type {Grammar<TPath, TProcessOptions>} */
 		this._grammar = grammar;
-		/** @type {CompiledVisitorMap<TNode>} */
+		/** @type {CompiledVisitorMap<TPath>} */
 		this._visitors = [];
+		/** @type {TProcessOptions | undefined} */
+		this._options = options;
 	}
 
 	/**
 	 * Register a Babel-style visitor map; calls accumulate per node type.
 	 * A bucket is a function (= `{ enter }`) or `{ enter?, exit? }`.
-	 * @param {VisitorMap<TNode>} map visitor map keyed by node type
-	 * @returns {SourceProcessor<TNode, TProcessOptions>} `this`, for chaining
+	 * @param {VisitorMap<TPath>} map visitor map keyed by node type
+	 * @returns {SourceProcessor<TPath, TProcessOptions>} `this`, for chaining
 	 */
 	use(map) {
 		// `map`'s keys are node-type enum members; `Object.keys` stringifies them,
@@ -90,15 +98,20 @@ class SourceProcessor {
 
 	/**
 	 * Run the grammar over `input`, firing visitors in source order. No
-	 * AST retained.
+	 * AST retained. Per-call `options` override the instance defaults.
 	 * @param {string} input source text
 	 * @param {TProcessOptions=} options grammar-specific options
 	 */
 	process(input, options) {
+		const defaults = this._options;
 		this._grammar(
 			input,
 			this._visitors,
-			options || /** @type {TProcessOptions} */ ({})
+			defaults
+				? options
+					? { ...defaults, ...options }
+					: defaults
+				: options || /** @type {TProcessOptions} */ ({})
 		);
 	}
 }

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");
 	}
 };
 

package/lib/util/deterministicGrouping.js

@@ -168,15 +168,14 @@ const getTooSmallTypes = (size, minSize) => {
 
 /**
  * Gets number of matching size types.
- * @template {object} T
- * @param {T} size size
+ * @param {Sizes} size size
  * @param {Types} types types
  * @returns {number} number of matching size types
  */
 const getNumberOfMatchingSizeTypes = (size, types) => {
 	let i = 0;
 	for (const key in size) {
-		if (size[/** @type {keyof T} */ (key)] !== 0 && types.has(key)) i++;
+		if (size[key] !== 0 && types.has(key)) i++;
 	}
 	return i;
 };
@@ -378,9 +377,12 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 				);
 				if (possibleResultGroups.length > 0) {
 					const bestGroup = possibleResultGroups.reduce((min, group) => {
-						const minMatches = getNumberOfMatchingSizeTypes(min, problemTypes);
+						const minMatches = getNumberOfMatchingSizeTypes(
+							min.size,
+							problemTypes
+						);
 						const groupMatches = getNumberOfMatchingSizeTypes(
-							group,
+							group.size,
 							problemTypes
 						);
 						if (minMatches !== groupMatches) {

package/lib/util/formatSize.js

@@ -19,8 +19,12 @@ const formatSize = (size) => {
 		return "0 bytes";
 	}
 
-	const abbreviations = ["bytes", "KiB", "MiB", "GiB"];
-	const index = Math.floor(Math.log(size) / Math.log(1024));
+	const abbreviations = ["bytes", "KiB", "MiB", "GiB", "TiB", "PiB"];
+	// clamp so sizes beyond the largest unit don't index past the table
+	const index = Math.min(
+		Math.floor(Math.log(size) / Math.log(1024)),
+		abbreviations.length - 1
+	);
 
 	return `${Number((size / 1024 ** index).toPrecision(3))} ${abbreviations[index]}`;
 };