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

package/lib/util/StackedMap.js

@@ -9,16 +9,22 @@ const TOMBSTONE = Symbol("tombstone");
 const UNDEFINED_MARKER = Symbol("undefined");
 
 /**
+ * Public cell value exposed by `StackedMap`, where `undefined` is preserved as
+ * a valid stored result.
  * @template T
  * @typedef {T | undefined} Cell<T>
  */
 
 /**
+ * Internal cell value used to distinguish deleted entries and explicit
+ * `undefined` assignments while traversing stacked scopes.
  * @template T
  * @typedef {T | typeof TOMBSTONE | typeof UNDEFINED_MARKER} InternalCell<T>
  */
 
 /**
+ * Converts an internal key/value pair into the external representation returned
+ * by iteration helpers.
  * @template K
  * @template V
  * @param {[K, InternalCell<V>]} pair the internal cell
@@ -34,130 +40,243 @@ const extractPair = (pair) => {
 };
 
 /**
+ * Layered map that supports child scopes while memoizing lookups from parent
+ * 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 {
 	/**
-	 * @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;
 	}
 
 	/**
+	 * Stores a value in the current layer, preserving explicit `undefined`
+	 * values with an internal marker.
 	 * @param {K} item the key of the element to add
 	 * @param {V} value the value of the element to add
 	 * @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
+		);
 	}
 
 	/**
+	 * Deletes a key from the current view, either by removing it outright in the
+	 * root layer or by recording a tombstone in child layers.
 	 * @param {K} item the item to delete
 	 * @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 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
+	 * 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 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;
 	}
 
+	/**
+	 * Returns the visible keys as an array after collapsing the stack.
+	 * @returns {K[]} array of keys
+	 */
 	asArray() {
 		this._compress();
-		return [...this.map.keys()];
+		return [.../** @type {Map<K, InternalCell<V>>} */ (this.map).keys()];
 	}
 
+	/**
+	 * Returns the visible keys as a `Set` after collapsing the stack.
+	 * @returns {Set<K>} set of keys
+	 */
 	asSet() {
 		this._compress();
-		return new Set(this.map.keys());
+		return new Set(/** @type {Map<K, InternalCell<V>>} */ (this.map).keys());
 	}
 
+	/**
+	 * Returns visible key/value pairs using the external representation.
+	 * @returns {[K, Cell<V>][]} array of key/value pairs
+	 */
 	asPairArray() {
 		this._compress();
-		return Array.from(this.map.entries(), extractPair);
+		return Array.from(
+			/** @type {Map<K, InternalCell<V>>} */ (this.map).entries(),
+			extractPair
+		);
 	}
 
+	/**
+	 * Returns the visible contents as a plain `Map`.
+	 * @returns {Map<K, Cell<V>>} materialized map
+	 */
 	asMap() {
 		return new Map(this.asPairArray());
 	}
 
+	/**
+	 * Returns the number of visible keys after collapsing the stack.
+	 * @returns {number} number of keys
+	 */
 	get size() {
 		this._compress();
-		return this.map.size;
+		return /** @type {Map<K, InternalCell<V>>} */ (this.map).size;
 	}
 
+	/**
+	 * Creates a child `StackedMap` that sees the current layers as its parent
+	 * scope.
+	 * @returns {StackedMap<K, V>} child map
+	 */
 	createChild() {
-		return new StackedMap(this.stack);
+		return new StackedMap(this);
 	}
 }
 

package/lib/util/StringXor.js

@@ -41,7 +41,7 @@ class StringXor {
 	}
 
 	/**
-	 * Adds a string to the current StringXor object.
+	 * Processes the provided str.
 	 * @param {string} str string
 	 * @returns {void}
 	 */

package/lib/util/TupleQueue.js

@@ -8,11 +8,14 @@
 const TupleSet = require("./TupleSet");
 
 /**
+ * FIFO queue for tuples that preserves uniqueness by delegating membership
+ * tracking to `TupleSet`.
  * @template T
  * @template V
  */
 class TupleQueue {
 	/**
+	 * Seeds the queue with an optional iterable of tuples to visit.
 	 * @param {Iterable<[T, V, ...EXPECTED_ANY]>=} items The initial elements.
 	 */
 	constructor(items) {
@@ -29,7 +32,7 @@ class TupleQueue {
 	}
 
 	/**
-	 * Returns the number of elements in this queue.
+	 * Returns the number of distinct tuples currently queued.
 	 * @returns {number} The number of elements in this queue.
 	 */
 	get length() {
@@ -37,7 +40,7 @@ class TupleQueue {
 	}
 
 	/**
-	 * Appends the specified element to this queue.
+	 * Enqueues a tuple if it is not already present in the underlying set.
 	 * @param {[T, V, ...EXPECTED_ANY]} item The element to add.
 	 * @returns {void}
 	 */
@@ -46,7 +49,8 @@ class TupleQueue {
 	}
 
 	/**
-	 * Retrieves and removes the head of this queue.
+	 * Removes and returns the next queued tuple, rebuilding the iterator when
+	 * the underlying tuple set has changed since the last full pass.
 	 * @returns {[T, V, ...EXPECTED_ANY] | undefined} The head of the queue of `undefined` if this queue is empty.
 	 */
 	dequeue() {

package/lib/util/TupleSet.js

@@ -6,22 +6,28 @@
 "use strict";
 
 /**
+ * Nested map structure used to index tuple prefixes until the final tuple
+ * element can be stored in a `Set`.
  * @template K
  * @template V
  * @typedef {Map<K, InnerMap<K, V> | Set<V>>} InnerMap
  */
 
 /**
+ * Stores tuples of arbitrary length while preserving efficient prefix lookups
+ * through a tree of maps that ends in a set of final values.
  * @template T
  * @template V
  */
 class TupleSet {
 	/**
+	 * Seeds the tuple set with an optional iterable of tuples.
 	 * @param {Iterable<[T, V, ...EXPECTED_ANY]>=} init init
 	 */
 	constructor(init) {
 		/** @type {InnerMap<T, V>} */
 		this._map = new Map();
+		/** @type {number} */
 		this.size = 0;
 		if (init) {
 			for (const tuple of init) {
@@ -31,6 +37,7 @@ class TupleSet {
 	}
 
 	/**
+	 * Adds a tuple to the set, creating any missing prefix maps along the way.
 	 * @param {[T, V, ...EXPECTED_ANY]} args tuple
 	 * @returns {void}
 	 */
@@ -59,6 +66,7 @@ class TupleSet {
 	}
 
 	/**
+	 * Checks whether the exact tuple is already present in the set.
 	 * @param {[T, V, ...EXPECTED_ANY]} args tuple
 	 * @returns {boolean} true, if the tuple is in the Set
 	 */
@@ -83,6 +91,7 @@ class TupleSet {
 	}
 
 	/**
+	 * Removes a tuple from the set when it is present.
 	 * @param {[T, V, ...EXPECTED_ANY]} args tuple
 	 * @returns {void}
 	 */
@@ -109,10 +118,13 @@ class TupleSet {
 	}
 
 	/**
+	 * Iterates over every stored tuple by walking the nested map structure and
+	 * yielding each complete prefix plus its terminal set value.
 	 * @returns {Iterator<[T, V, ...EXPECTED_ANY]>} iterator
 	 */
 	[Symbol.iterator]() {
 		/**
+		 * Iterator type used while traversing nested tuple-prefix maps.
 		 * @template T, V
 		 * @typedef {MapIterator<[T, InnerMap<T, V> | Set<V>]>} IteratorStack
 		 */
@@ -127,6 +139,8 @@ class TupleSet {
 		let currentSetIterator;
 
 		/**
+		 * Advances through nested maps until a terminal value set is reached or
+		 * every remaining branch has been exhausted.
 		 * @param {IteratorStack<T, V>} it iterator
 		 * @returns {boolean} result
 		 */

package/lib/util/URLAbsoluteSpecifier.js

@@ -74,6 +74,7 @@ function getScheme(specifier) {
 }
 
 /**
+ * Returns protocol if absolute URL specifier provided.
  * @param {string} specifier specifier
  * @returns {string | null | undefined} protocol if absolute URL specifier provided
  */

package/lib/util/WeakTupleMap.js

@@ -6,35 +6,49 @@
 "use strict";
 
 /**
+ * Strong-key child map used for tuple elements that cannot be stored in a
+ * `WeakMap`.
  * @template {EXPECTED_ANY[]} T
  * @template V
  * @typedef {Map<EXPECTED_ANY, WeakTupleMap<T, V>>} M
  */
 
 /**
+ * Weak-key child map used for tuple elements that are objects and can be held
+ * without preventing garbage collection.
  * @template {EXPECTED_ANY[]} T
  * @template V
  * @typedef {WeakMap<EXPECTED_OBJECT, WeakTupleMap<T, V>>} W
  */
 
 /**
+ * Reports whether a tuple element can be stored in a `WeakMap`.
  * @param {EXPECTED_ANY} thing thing
  * @returns {boolean} true if is weak
  */
 const isWeakKey = (thing) => typeof thing === "object" && thing !== null;
 
 /**
+ * Extracts the element type from a tuple-like array.
  * @template {unknown[]} T
  * @typedef {T extends ReadonlyArray<infer ElementType> ? ElementType : never} ArrayElement
  */
 
 /**
+ * Stores values by tuple keys while using `WeakMap` for object elements so the
+ * cache can release entries when those objects are collected.
  * @template {EXPECTED_ANY[]} K
  * @template V
  */
 class WeakTupleMap {
+	/**
+	 * Initializes an empty tuple trie node with optional value and child maps.
+	 */
 	constructor() {
-		/** @private */
+		/**
+		 * @private
+		 * @type {number}
+		 */
 		this.f = 0;
 		/**
 		 * @private
@@ -54,6 +68,7 @@ class WeakTupleMap {
 	}
 
 	/**
+	 * Stores a value at the node identified by the provided tuple key.
 	 * @param {[...K, V]} args tuple
 	 * @returns {void}
 	 */
@@ -67,6 +82,7 @@ class WeakTupleMap {
 	}
 
 	/**
+	 * Checks whether the exact tuple key has a stored value.
 	 * @param {K} args tuple
 	 * @returns {boolean} true, if the tuple is in the Set
 	 */
@@ -81,6 +97,7 @@ class WeakTupleMap {
 	}
 
 	/**
+	 * Returns the value stored for the exact tuple key, if any.
 	 * @param {K} args tuple
 	 * @returns {V | undefined} the value
 	 */
@@ -95,6 +112,8 @@ class WeakTupleMap {
 	}
 
 	/**
+	 * Returns an existing value for the tuple or computes, stores, and returns a
+	 * new one when the tuple is missing.
 	 * @param {[...K, (...args: K) => V]} args tuple
 	 * @returns {V} the value
 	 */
@@ -112,6 +131,30 @@ class WeakTupleMap {
 	}
 
 	/**
+	 * Memoizes `compute(thisArg, ...args)` under the tuple key `[compute,
+	 * ...args]`, computing it on a miss. Equivalent to `provide(compute, ...args,
+	 * () => compute(thisArg, ...args))` but without allocating that closure (or an
+	 * extra rest array) on every call — `ModuleGraph#cached` runs this on hot
+	 * paths where most calls hit the cache and the closure would be pure waste.
+	 * @param {(thisArg: EXPECTED_ANY, ...args: K) => V} compute computer, also the first key element
+	 * @param {EXPECTED_ANY} thisArg first argument passed to `compute`
+	 * @param {K} args remaining key elements, also passed to `compute`
+	 * @returns {V} the value
+	 */
+	cachedProvide(compute, thisArg, args) {
+		/** @type {WeakTupleMap<K, V>} */
+		let node = this._get(/** @type {ArrayElement<K>} */ (compute));
+		for (let i = 0; i < args.length; i++) {
+			node = node._get(/** @type {ArrayElement<K>} */ (args[i]));
+		}
+		if (node._hasValue()) return /** @type {V} */ (node._getValue());
+		const newValue = compute(thisArg, ...args);
+		node._setValue(newValue);
+		return newValue;
+	}
+
+	/**
+	 * Removes the value stored for the tuple key without pruning the trie.
 	 * @param {K} args tuple
 	 * @returns {void}
 	 */
@@ -126,6 +169,7 @@ class WeakTupleMap {
 	}
 
 	/**
+	 * Clears the stored value and all strong and weak child maps from this node.
 	 * @returns {void}
 	 */
 	clear() {
@@ -135,15 +179,24 @@ class WeakTupleMap {
 		this.m = undefined;
 	}
 
+	/**
+	 * Returns the value stored directly on this trie node.
+	 * @returns {V | undefined} stored value
+	 */
 	_getValue() {
 		return this.v;
 	}
 
+	/**
+	 * Reports whether this trie node currently stores a value.
+	 * @returns {boolean} true when a value is present
+	 */
 	_hasValue() {
 		return (this.f & 1) === 1;
 	}
 
 	/**
+	 * Stores a value directly on this trie node.
 	 * @param {V} v value
 	 * @private
 	 */
@@ -152,12 +205,16 @@ class WeakTupleMap {
 		this.v = v;
 	}
 
+	/**
+	 * Removes the value stored directly on this trie node.
+	 */
 	_deleteValue() {
 		this.f &= 6;
 		this.v = undefined;
 	}
 
 	/**
+	 * Returns the child node for a tuple element without creating one.
 	 * @param {ArrayElement<K>} thing thing
 	 * @returns {WeakTupleMap<K, V> | undefined} thing
 	 * @private
@@ -176,6 +233,8 @@ class WeakTupleMap {
 	}
 
 	/**
+	 * Returns the child node for a tuple element, creating and storing it when
+	 * necessary.
 	 * @private
 	 * @param {ArrayElement<K>} thing thing
 	 * @returns {WeakTupleMap<K, V>} value

package/lib/util/binarySearchBounds.js

@@ -65,6 +65,7 @@ const compileSearch = (funcName, predicate, reversed, extraArgs, earlyOut) => {
 };
 
 /**
+ * Defines the search type used by this module.
  * @template T
  * @typedef {(items: T[], start: number, compareFn?: number | ((item: T, needle: number) => number), l?: number, h?: number) => number} Search
  */
@@ -127,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/chainedImports.js

@@ -71,8 +71,8 @@ module.exports.getTrimmedIdsAndRange = (
  * @returns {string[]} trimmed ids
  */
 function trimIdsToThoseImported(ids, moduleGraph, dependency) {
-	/** @type {string[]} */
-	let trimmedIds = [];
+	/** @type {string[] | undefined} */
+	let trimmedIds;
 	let currentExportsInfo = moduleGraph.getExportsInfo(
 		/** @type {Module} */ (moduleGraph.getModule(dependency))
 	);
@@ -95,5 +95,5 @@ function trimIdsToThoseImported(ids, moduleGraph, dependency) {
 		currentExportsInfo = nestedInfo;
 	}
 	// Never trim to nothing.  This can happen for invalid imports (e.g. import { notThere } from "./module", or import { anything } from "./missingModule")
-	return trimmedIds.length ? trimmedIds : ids;
+	return trimmedIds !== undefined && trimmedIds.length ? trimmedIds : ids;
 }