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

package/lib/util/LazySet.js

@@ -8,6 +8,7 @@
 const makeSerializable = require("./makeSerializable");
 
 /**
+ * Merges every queued iterable directly into the concrete backing set.
  * @template T
  * @param {Set<T>} targetSet set where items should be added
  * @param {Set<Iterable<T>>} toMerge iterables to be merged
@@ -22,6 +23,8 @@ const merge = (targetSet, toMerge) => {
 };
 
 /**
+ * Flattens nested `LazySet` instances into a single collection of iterables
+ * that can later be merged into the backing set.
  * @template T
  * @param {Set<Iterable<T>>} targetSet set where iterables should be added
  * @param {LazySet<T>[]} toDeepMerge lazy sets to be flattened
@@ -40,6 +43,7 @@ const flatten = (targetSet, toDeepMerge) => {
 };
 
 /**
+ * Defines the set iterator type used by this module.
  * @template T
  * @typedef {import("typescript-iterable").SetIterator<T>} SetIterator
  */
@@ -52,6 +56,8 @@ const flatten = (targetSet, toDeepMerge) => {
  */
 class LazySet {
 	/**
+	 * Seeds the set with an optional iterable while preparing internal queues for
+	 * deferred merges.
 	 * @param {Iterable<T>=} iterable init iterable
 	 */
 	constructor(iterable) {
@@ -61,15 +67,23 @@ class LazySet {
 		this._toMerge = new Set();
 		/** @type {LazySet<T>[]} */
 		this._toDeepMerge = [];
+		/** @type {boolean} */
 		this._needMerge = false;
+		/** @type {boolean} */
 		this._deopt = false;
 	}
 
+	/**
+	 * Flattens any nested lazy sets that were queued for merging.
+	 */
 	_flatten() {
 		flatten(this._toMerge, this._toDeepMerge);
 		this._toDeepMerge.length = 0;
 	}
 
+	/**
+	 * Materializes all deferred additions into the backing set.
+	 */
 	_merge() {
 		this._flatten();
 		merge(this._set, this._toMerge);
@@ -77,6 +91,10 @@ class LazySet {
 		this._needMerge = false;
 	}
 
+	/**
+	 * Reports whether the set is empty without forcing a full merge.
+	 * @returns {boolean} true when no items have been stored or queued
+	 */
 	_isEmpty() {
 		return (
 			this._set.size === 0 &&
@@ -85,12 +103,17 @@ class LazySet {
 		);
 	}
 
+	/**
+	 * Returns the number of items after applying any deferred merges.
+	 * @returns {number} number of items in the set
+	 */
 	get size() {
 		if (this._needMerge) this._merge();
 		return this._set.size;
 	}
 
 	/**
+	 * Adds a single item immediately to the concrete backing set.
 	 * @param {T} item an item
 	 * @returns {LazySet<T>} itself
 	 */
@@ -100,6 +123,8 @@ class LazySet {
 	}
 
 	/**
+	 * Queues another iterable or lazy set for later merging so large bulk adds
+	 * can stay cheap until the set is read.
 	 * @param {Iterable<T> | LazySet<T>} iterable a immutable iterable or another immutable LazySet which will eventually be merged into the Set
 	 * @returns {LazySet<T>} itself
 	 */
@@ -126,6 +151,9 @@ class LazySet {
 		return this;
 	}
 
+	/**
+	 * Removes all items and clears every deferred merge queue.
+	 */
 	clear() {
 		this._set.clear();
 		this._toMerge.clear();
@@ -135,6 +163,8 @@ class LazySet {
 	}
 
 	/**
+	 * Deletes an item after first materializing any deferred additions that may
+	 * contain it.
 	 * @param {T} value an item
 	 * @returns {boolean} true, if the value was in the Set before
 	 */
@@ -144,6 +174,8 @@ class LazySet {
 	}
 
 	/**
+	 * Returns the set's entry iterator and permanently switches future
+	 * operations to eager merge mode to preserve iterator correctness.
 	 * @returns {SetIterator<[T, T]>} entries
 	 */
 	entries() {
@@ -153,6 +185,8 @@ class LazySet {
 	}
 
 	/**
+	 * Iterates over every item after forcing pending merges and switching to
+	 * eager mode for correctness during iteration.
 	 * @template K
 	 * @param {(value: T, value2: T, set: Set<T>) => void} callbackFn function called for each entry
 	 * @param {K} thisArg this argument for the callbackFn
@@ -166,6 +200,7 @@ class LazySet {
 	}
 
 	/**
+	 * Checks whether an item is present after applying any deferred merges.
 	 * @param {T} item an item
 	 * @returns {boolean} true, when the item is in the Set
 	 */
@@ -175,6 +210,7 @@ class LazySet {
 	}
 
 	/**
+	 * Returns the key iterator, eagerly materializing pending merges first.
 	 * @returns {SetIterator<T>} keys
 	 */
 	keys() {
@@ -184,6 +220,7 @@ class LazySet {
 	}
 
 	/**
+	 * Returns the value iterator, eagerly materializing pending merges first.
 	 * @returns {SetIterator<T>} values
 	 */
 	values() {
@@ -193,6 +230,7 @@ class LazySet {
 	}
 
 	/**
+	 * Returns the default iterator over values after forcing pending merges.
 	 * @returns {SetIterator<T>} iterable iterator
 	 */
 	[Symbol.iterator]() {
@@ -207,7 +245,9 @@ class LazySet {
 	}
 
 	/**
-	 * @param {import("../serialization/ObjectMiddleware").ObjectSerializerContext} context context
+	 * Serializes the fully materialized set contents into webpack's object
+	 * serialization stream.
+	 * @param {import("../serialization/ObjectMiddleware").ObjectSerializerContext<(number | T)[]>} context context
 	 */
 	serialize({ write }) {
 		if (this._needMerge) this._merge();
@@ -216,16 +256,17 @@ class LazySet {
 	}
 
 	/**
+	 * Restores a `LazySet` from serialized item data.
 	 * @template T
-	 * @param {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} context context
+	 * @param {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<(number | T)[]>} context context
 	 * @returns {LazySet<T>} lazy set
 	 */
 	static deserialize({ read }) {
-		const count = read();
+		const count = /** @type {number} */ (read());
 		/** @type {T[]} */
 		const items = [];
 		for (let i = 0; i < count; i++) {
-			items.push(read());
+			items.push(/** @type {T} */ (read()));
 		}
 		return new LazySet(items);
 	}

package/lib/util/LocConverter.js

@@ -0,0 +1,64 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+class LocConverter {
+	/**
+	 * Creates an instance of LocConverter.
+	 * @param {string} input input
+	 */
+	constructor(input) {
+		/** @type {string} */
+		this._input = input;
+		/** @type {number} */
+		this.line = 1;
+		/** @type {number} */
+		this.column = 0;
+		/** @type {number} */
+		this.pos = 0;
+	}
+
+	/**
+	 * Returns location converter.
+	 * @param {number} pos position
+	 * @returns {LocConverter} location converter
+	 */
+	get(pos) {
+		if (this.pos !== pos) {
+			if (this.pos < pos) {
+				// Advance: delta-bounded scan of [this.pos, pos), allocation-free
+				// (unbounded index scans go quadratic on newline-free input).
+				const input = this._input;
+				let last = -1;
+				for (let j = this.pos; j < pos; j++) {
+					if (input.charCodeAt(j) === 10) {
+						this.line++;
+						last = j;
+					}
+				}
+				this.column =
+					last === -1 ? this.column + (pos - this.pos) : pos - last - 1;
+			} else {
+				// Retreat: count newlines crossed in (pos, this.pos), i.e.
+				// exclude the newline at `this.pos` itself. By convention a
+				// `\n` is the last column of its line, so when `this.pos`
+				// sits on one we're already on the line containing it; only
+				// newlines strictly **before** `this.pos` and at-or-after
+				// `pos` represent crossed line boundaries.
+				let i = this._input.lastIndexOf("\n", this.pos - 1);
+				while (i >= pos) {
+					this.line--;
+					i = i > 0 ? this._input.lastIndexOf("\n", i - 1) : -1;
+				}
+				this.column = i === -1 ? pos : pos - i - 1;
+			}
+			this.pos = pos;
+		}
+		return this;
+	}
+}
+
+module.exports = LocConverter;

package/lib/util/ParallelismFactorCalculator.js

@@ -18,6 +18,7 @@ class ParallelismFactorCalculator {
 	}
 
 	/**
+	 * Processes the provided start.
 	 * @param {number} start range start
 	 * @param {number} end range end
 	 * @param {Callback} callback callback

package/lib/util/Queue.js

@@ -6,10 +6,13 @@
 "use strict";
 
 /**
+ * FIFO queue that keeps items unique by storing them in insertion order inside
+ * a `Set`.
  * @template T
  */
 class Queue {
 	/**
+	 * Seeds the queue with an optional iterable of initial unique items.
 	 * @param {Iterable<T>=} items The initial elements.
 	 */
 	constructor(items) {
@@ -21,7 +24,7 @@ class Queue {
 	}
 
 	/**
-	 * Returns the number of elements in this queue.
+	 * Returns the number of unique items currently waiting in the queue.
 	 * @returns {number} The number of elements in this queue.
 	 */
 	get length() {
@@ -29,7 +32,7 @@ class Queue {
 	}
 
 	/**
-	 * Appends the specified element to this queue.
+	 * Enqueues an item, moving nothing if that value is already present.
 	 * @param {T} item The element to add.
 	 * @returns {void}
 	 */
@@ -38,7 +41,7 @@ class Queue {
 	}
 
 	/**
-	 * Retrieves and removes the head of this queue.
+	 * Removes and returns the oldest enqueued item.
 	 * @returns {T | undefined} The head of the queue of `undefined` if this queue is empty.
 	 */
 	dequeue() {

package/lib/util/Semaphore.js

@@ -5,13 +5,19 @@
 
 "use strict";
 
+/**
+ * Simple counting semaphore used to limit how many asynchronous tasks may run
+ * concurrently.
+ */
 class Semaphore {
 	/**
-	 * Creates an instance of Semaphore.
+	 * Initializes the semaphore with the number of permits that may be held at
+	 * the same time.
 	 * @param {number} available the amount available number of "tasks"
 	 * in the Semaphore
 	 */
 	constructor(available) {
+		/** @type {number} */
 		this.available = available;
 		/** @type {(() => void)[]} */
 		this.waiters = [];
@@ -20,6 +26,8 @@ class Semaphore {
 	}
 
 	/**
+	 * Acquires a permit for the callback immediately when one is available or
+	 * queues the callback until another task releases its permit.
 	 * @param {() => void} callback function block to capture and run
 	 * @returns {void}
 	 */
@@ -32,6 +40,9 @@ class Semaphore {
 		}
 	}
 
+	/**
+	 * Releases a permit and schedules the next waiting callback, if any.
+	 */
 	release() {
 		this.available++;
 		if (this.waiters.length > 0) {
@@ -39,6 +50,9 @@ class Semaphore {
 		}
 	}
 
+	/**
+	 * Drains the next waiting callback after a permit becomes available.
+	 */
 	_continue() {
 		if (this.available > 0 && this.waiters.length > 0) {
 			this.available--;

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;
@@ -52,6 +52,7 @@ const isSubset = (bigSet, smallSet) => {
 };
 
 /**
+ * Returns found item.
  * @template T
  * @param {Set<T>} set a set
  * @param {(set: T) => boolean} fn selector function
@@ -64,6 +65,7 @@ const find = (set, fn) => {
 };
 
 /**
+ * Returns first item.
  * @template T
  * @param {Set<T> | ReadonlySet<T>} set a set
  * @returns {T | undefined} first item
@@ -74,6 +76,7 @@ const first = (set) => {
 };
 
 /**
+ * Returns combined set, may be identical to a or b.
  * @template T
  * @param {Set<T>} a first
  * @param {Set<T>} b second

package/lib/util/SortableSet.js

@@ -47,6 +47,7 @@ class SortableSet extends Set {
 	}
 
 	/**
+	 * Returns itself.
 	 * @param {T} value value to add to set
 	 * @returns {this} returns itself
 	 */
@@ -59,6 +60,7 @@ class SortableSet extends Set {
 	}
 
 	/**
+	 * Returns true if value existed in set, false otherwise.
 	 * @param {T} value value to delete
 	 * @returns {boolean} true if value existed in set, false otherwise
 	 */
@@ -69,6 +71,7 @@ class SortableSet extends Set {
 	}
 
 	/**
+	 * Describes how this clear operation behaves.
 	 * @returns {void}
 	 */
 	clear() {
@@ -105,7 +108,7 @@ class SortableSet extends Set {
 
 	/**
 	 * Get data from cache
-	 * @template {EXPECTED_ANY} R
+	 * @template R
 	 * @param {(set: SortableSet<T>) => R} fn function to calculate value
 	 * @returns {R} returns result of fn(this), cached until set changes
 	 */
@@ -146,6 +149,7 @@ class SortableSet extends Set {
 	}
 
 	/**
+	 * Invalidates the cached state associated with this value.
 	 * @private
 	 * @returns {void}
 	 */
@@ -156,6 +160,7 @@ class SortableSet extends Set {
 	}
 
 	/**
+	 * Invalidate ordered cache.
 	 * @private
 	 * @returns {void}
 	 */
@@ -166,6 +171,7 @@ class SortableSet extends Set {
 	}
 
 	/**
+	 * Returns the raw array.
 	 * @returns {T[]} the raw array
 	 */
 	toJSON() {

package/lib/util/SourceProcessor.js

@@ -0,0 +1,119 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+/**
+ * Babel-style visitor map keyed by a numeric node-type discriminator; a bucket
+ * 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 TPath
+ * @typedef {VisitorFn<TPath> | { enter?: VisitorFn<TPath>, exit?: VisitorFn<TPath> }} VisitorBucket
+ */
+/**
+ * @template TPath
+ * @typedef {{ [nodeType: number]: VisitorBucket<TPath> }} VisitorMap
+ */
+/**
+ * @template TPath
+ * @typedef {{ enter: VisitorFn<TPath>[], exit: VisitorFn<TPath>[] }} CompiledVisitorBucket
+ */
+/**
+ * @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, walking — and the `path`
+ * object each visitor receives).
+ * @template TPath
+ * @template TProcessOptions
+ * @typedef {(input: string, visitors: CompiledVisitorMap<TPath>, options: TProcessOptions) => void} Grammar
+ */
+
+/**
+ * Visitor coordinator: owns the visitor registry and drives a language
+ * `grammar` over the source. Language-agnostic — each syntax (CSS, HTML, …)
+ * binds its own grammar and node-type enum. Babel-style usage:
+ *
+ * ```
+ * processor.use({ [NodeType.X]: (path) => {}, [NodeType.Y]: { enter, exit } });
+ * processor.process(source);
+ * ```
+ * @template TPath
+ * @template [TProcessOptions=object]
+ */
+class SourceProcessor {
+	/**
+	 * @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, options) {
+		/** @type {Grammar<TPath, TProcessOptions>} */
+		this._grammar = grammar;
+		/** @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<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,
+		// so index the compiled array by the number to match the numeric `node.type`.
+		for (const type of Object.keys(map)) {
+			const key = Number(type);
+			const v = map[key];
+			let bucket = this._visitors[key];
+			if (!bucket) {
+				bucket = { enter: [], exit: [] };
+				this._visitors[key] = bucket;
+			}
+			if (typeof v === "function") {
+				bucket.enter.push(v);
+			} else {
+				if (v.enter) bucket.enter.push(v.enter);
+				if (v.exit) bucket.exit.push(v.exit);
+			}
+		}
+		return this;
+	}
+
+	/**
+	 * Run the grammar over `input`, firing visitors in source order. No
+	 * 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,
+			defaults
+				? options
+					? { ...defaults, ...options }
+					: defaults
+				: options || /** @type {TProcessOptions} */ ({})
+		);
+	}
+}
+
+module.exports = SourceProcessor;

package/lib/util/StackedCacheMap.js

@@ -31,6 +31,10 @@
  * @template V
  */
 class StackedCacheMap {
+	/**
+	 * Initializes the mutable fallback map and the stack of immutable cache
+	 * layers.
+	 */
 	constructor() {
 		/** @type {Map<K, V>} */
 		this.map = new Map();
@@ -39,9 +43,9 @@ class StackedCacheMap {
 	}
 
 	/**
-	 * If `immutable` is true, the map can be referenced by the StackedCacheMap
-	 * and should not be changed afterwards. If the map is mutable, all items
-	 * are copied into a fallback Map.
+	 * Adds another cache layer. Immutable maps are retained by reference and
+	 * reordered so larger layers are checked first, while mutable maps are
+	 * copied into the fallback map.
 	 * @param {ReadonlyMap<K, V>} map map to add
 	 * @param {boolean=} immutable if 'map' is immutable and StackedCacheMap can keep referencing it
 	 */
@@ -64,6 +68,7 @@ class StackedCacheMap {
 	}
 
 	/**
+	 * Stores or overrides a value in the mutable fallback map.
 	 * @param {K} item the key of the element to add
 	 * @param {V} value the value of the element to add
 	 * @returns {void}
@@ -73,6 +78,8 @@ class StackedCacheMap {
 	}
 
 	/**
+	 * Rejects deletions because this data structure is optimized for append-only
+	 * cache layers.
 	 * @param {K} item the item to delete
 	 * @returns {void}
 	 */
@@ -81,6 +88,8 @@ class StackedCacheMap {
 	}
 
 	/**
+	 * Rejects `has` checks because they would force the same layered lookup work
+	 * as `get` without returning the cached value.
 	 * @param {K} item the item to test
 	 * @returns {boolean} true if the item exists in this set
 	 */
@@ -91,6 +100,8 @@ class StackedCacheMap {
 	}
 
 	/**
+	 * Looks up a key by scanning immutable cache layers first and then the
+	 * mutable fallback map.
 	 * @param {K} item the key of the element to return
 	 * @returns {V | undefined} the value of the element
 	 */
@@ -102,12 +113,17 @@ class StackedCacheMap {
 		return this.map.get(item);
 	}
 
+	/**
+	 * Removes every cache layer and clears the mutable fallback map.
+	 */
 	clear() {
 		this.stack.length = 0;
 		this.map.clear();
 	}
 
 	/**
+	 * Returns the total number of entries across the fallback map and all stacked
+	 * cache layers.
 	 * @returns {number} size of the map
 	 */
 	get size() {
@@ -119,6 +135,7 @@ class StackedCacheMap {
 	}
 
 	/**
+	 * Iterates over the fallback map first and then each stacked cache layer.
 	 * @returns {Iterator<[K, V]>} iterator
 	 */
 	[Symbol.iterator]() {