webpack 5.106.1 → 5.107.0

package/lib/util/LocConverter.js

@@ -0,0 +1,53 @@
+/*
+	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) {
+		this._input = input;
+		this.line = 1;
+		this.column = 0;
+		this.pos = 0;
+	}
+
+	/**
+	 * Returns location converter.
+	 * @param {number} pos position
+	 * @returns {LocConverter} location converter
+	 */
+	get(pos) {
+		if (this.pos !== pos) {
+			if (this.pos < pos) {
+				const str = this._input.slice(this.pos, pos);
+				let i = str.lastIndexOf("\n");
+				if (i === -1) {
+					this.column += str.length;
+				} else {
+					this.column = str.length - i - 1;
+					this.line++;
+					while (i > 0 && (i = str.lastIndexOf("\n", i - 1)) !== -1) {
+						this.line++;
+					}
+				}
+			} else {
+				let i = this._input.lastIndexOf("\n", this.pos);
+				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,9 +5,14 @@
 
 "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
 	 */
@@ -20,6 +25,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 +39,9 @@ class Semaphore {
 		}
 	}
 
+	/**
+	 * Releases a permit and schedules the next waiting callback, if any.
+	 */
 	release() {
 		this.available++;
 		if (this.waiters.length > 0) {
@@ -39,6 +49,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

@@ -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/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]() {

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,11 +40,14 @@ const extractPair = (pair) => {
 };
 
 /**
+ * Layered map that supports child scopes while memoizing lookups from parent
+ * scopes into the current layer.
  * @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
 	 */
 	constructor(parentStack) {
@@ -50,6 +59,8 @@ class StackedMap {
 	}
 
 	/**
+	 * 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}
@@ -59,6 +70,8 @@ class StackedMap {
 	}
 
 	/**
+	 * 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}
 	 */
@@ -71,6 +84,8 @@ class StackedMap {
 	}
 
 	/**
+	 * Checks whether a key exists in the current scope chain, caching any parent
+	 * lookup result in the current layer.
 	 * @param {K} item the item to test
 	 * @returns {boolean} true if the item exists in this set
 	 */
@@ -93,6 +108,8 @@ class StackedMap {
 	}
 
 	/**
+	 * Returns the visible value for a key, caching parent hits and misses in the
+	 * current layer.
 	 * @param {K} item the key of the element to return
 	 * @returns {Cell<V>} the value of the element
 	 */
@@ -117,6 +134,9 @@ class StackedMap {
 		}
 	}
 
+	/**
+	 * Collapses the stacked layers into a single concrete map.
+	 */
 	_compress() {
 		if (this.stack.length === 1) return;
 		this.map = new Map();
@@ -132,30 +152,55 @@ class StackedMap {
 		this.stack = [this.map];
 	}
 
+	/**
+	 * Returns the visible keys as an array after collapsing the stack.
+	 * @returns {K[]} array of keys
+	 */
 	asArray() {
 		this._compress();
 		return [...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());
 	}
 
+	/**
+	 * 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);
 	}
 
+	/**
+	 * 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;
 	}
 
+	/**
+	 * 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);
 	}

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,17 +6,22 @@
 "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) {
@@ -31,6 +36,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 +65,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 +90,7 @@ class TupleSet {
 	}
 
 	/**
+	 * Removes a tuple from the set when it is present.
 	 * @param {[T, V, ...EXPECTED_ANY]} args tuple
 	 * @returns {void}
 	 */
@@ -109,10 +117,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 +138,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
  */