webpack 5.97.1 → 5.104.1

package/lib/util/LazySet.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const makeSerializable = require("./makeSerializable.js");
+const makeSerializable = require("./makeSerializable");
 
 /**
  * @template T
@@ -24,7 +24,7 @@ const merge = (targetSet, toMerge) => {
 /**
  * @template T
  * @param {Set<Iterable<T>>} targetSet set where iterables should be added
- * @param {Array<LazySet<T>>} toDeepMerge lazy sets to be flattened
+ * @param {LazySet<T>[]} toDeepMerge lazy sets to be flattened
  * @returns {void}
  */
 const flatten = (targetSet, toDeepMerge) => {
@@ -39,6 +39,11 @@ const flatten = (targetSet, toDeepMerge) => {
 	}
 };
 
+/**
+ * @template T
+ * @typedef {import("typescript-iterable").SetIterator<T>} SetIterator
+ */
+
 /**
  * Like Set but with an addAll method to eventually add items from another iterable.
  * Access methods make sure that all delayed operations are executed.
@@ -54,7 +59,7 @@ class LazySet {
 		this._set = new Set(iterable);
 		/** @type {Set<Iterable<T>>} */
 		this._toMerge = new Set();
-		/** @type {Array<LazySet<T>>} */
+		/** @type {LazySet<T>[]} */
 		this._toDeepMerge = [];
 		this._needMerge = false;
 		this._deopt = false;
@@ -139,7 +144,7 @@ class LazySet {
 	}
 
 	/**
-	 * @returns {IterableIterator<[T, T]>} entries
+	 * @returns {SetIterator<[T, T]>} entries
 	 */
 	entries() {
 		this._deopt = true;
@@ -148,14 +153,15 @@ class LazySet {
 	}
 
 	/**
-	 * @param {function(T, T, Set<T>): void} callbackFn function called for each entry
-	 * @param {any} thisArg this argument for the callbackFn
+	 * @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
 	 * @returns {void}
 	 */
 	forEach(callbackFn, thisArg) {
 		this._deopt = true;
 		if (this._needMerge) this._merge();
-		// eslint-disable-next-line unicorn/no-array-for-each
+		// eslint-disable-next-line unicorn/no-array-for-each, unicorn/no-array-method-this-argument
 		this._set.forEach(callbackFn, thisArg);
 	}
 
@@ -169,7 +175,7 @@ class LazySet {
 	}
 
 	/**
-	 * @returns {IterableIterator<T>} keys
+	 * @returns {SetIterator<T>} keys
 	 */
 	keys() {
 		this._deopt = true;
@@ -178,7 +184,7 @@ class LazySet {
 	}
 
 	/**
-	 * @returns {IterableIterator<T>} values
+	 * @returns {SetIterator<T>} values
 	 */
 	values() {
 		this._deopt = true;
@@ -187,7 +193,7 @@ class LazySet {
 	}
 
 	/**
-	 * @returns {IterableIterator<T>} iterable iterator
+	 * @returns {SetIterator<T>} iterable iterator
 	 */
 	[Symbol.iterator]() {
 		this._deopt = true;

package/lib/util/MapHelpers.js

@@ -13,7 +13,7 @@
  * @template V
  * @param {Map<K, V>} map The map object to check
  * @param {K} key The key to check
- * @param {function(): V} computer function which will compute the value if it doesn't exist
+ * @param {() => V} computer function which will compute the value if it doesn't exist
  * @returns {V} The value from the map, or the computed value
  * @example
  * ```js

package/lib/util/ParallelismFactorCalculator.js

@@ -7,7 +7,7 @@
 
 const binarySearchBounds = require("./binarySearchBounds");
 
-/** @typedef {function(number): void} Callback */
+/** @typedef {(value: number) => void} Callback */
 
 class ParallelismFactorCalculator {
 	constructor() {
@@ -31,7 +31,7 @@ class ParallelismFactorCalculator {
 	}
 
 	calculate() {
-		const segments = Array.from(new Set(this._rangePoints)).sort((a, b) =>
+		const segments = [...new Set(this._rangePoints)].sort((a, b) =>
 			a < b ? -1 : 1
 		);
 		const parallelism = segments.map(() => 0);

package/lib/util/Semaphore.js

@@ -13,14 +13,14 @@ class Semaphore {
 	 */
 	constructor(available) {
 		this.available = available;
-		/** @type {(function(): void)[]} */
+		/** @type {(() => void)[]} */
 		this.waiters = [];
 		/** @private */
 		this._continue = this._continue.bind(this);
 	}
 
 	/**
-	 * @param {function(): void} callback function block to capture and run
+	 * @param {() => void} callback function block to capture and run
 	 * @returns {void}
 	 */
 	acquire(callback) {
@@ -42,7 +42,7 @@ class Semaphore {
 	_continue() {
 		if (this.available > 0 && this.waiters.length > 0) {
 			this.available--;
-			const callback = /** @type {(function(): void)} */ (this.waiters.pop());
+			const callback = /** @type {(() => void)} */ (this.waiters.pop());
 			callback();
 		}
 	}

package/lib/util/SetHelpers.js

@@ -11,7 +11,7 @@
  * @param {Set<T>[]} sets an array of sets being checked for shared elements
  * @returns {Set<T>} returns a new Set containing the intersecting items
  */
-const intersect = sets => {
+const intersect = (sets) => {
 	if (sets.length === 0) return new Set();
 	if (sets.length === 1) return new Set(sets[0]);
 	let minSize = Infinity;
@@ -54,7 +54,7 @@ const isSubset = (bigSet, smallSet) => {
 /**
  * @template T
  * @param {Set<T>} set a set
- * @param {function(T): boolean} fn selector function
+ * @param {(set: T) => boolean} fn selector function
  * @returns {T | undefined} found item
  */
 const find = (set, fn) => {
@@ -68,7 +68,7 @@ const find = (set, fn) => {
  * @param {Set<T> | ReadonlySet<T>} set a set
  * @returns {T | undefined} first item
  */
-const first = set => {
+const first = (set) => {
 	const entry = set.values().next();
 	return entry.done ? undefined : entry.value;
 };
@@ -87,8 +87,8 @@ const combine = (a, b) => {
 	return set;
 };
 
-module.exports.intersect = intersect;
-module.exports.isSubset = isSubset;
+module.exports.combine = combine;
 module.exports.find = find;
 module.exports.first = first;
-module.exports.combine = combine;
+module.exports.intersect = intersect;
+module.exports.isSubset = isSubset;

package/lib/util/SortableSet.js

@@ -16,8 +16,8 @@ class SortableSet extends Set {
 	/**
 	 * Create a new sortable set
 	 * @template T
+	 * @typedef {(a: T, b: T) => number} SortFunction
 	 * @param {Iterable<T>=} initialIterable The initial iterable value
-	 * @typedef {function(T, T): number} SortFunction
 	 * @param {SortFunction<T>=} defaultSort Default sorting function
 	 */
 	constructor(initialIterable, defaultSort) {
@@ -29,17 +29,19 @@ class SortableSet extends Set {
 		this._sortFn = defaultSort;
 		/**
 		 * @private
-		 * @type {typeof NONE | undefined | function(T, T): number}}
+		 * @type {typeof NONE | undefined | ((a: T, b: T) => number)}}
 		 */
 		this._lastActiveSortFn = NONE;
 		/**
 		 * @private
-		 * @type {Map<Function, any> | undefined}
+		 * @template R
+		 * @type {Map<(set: SortableSet<T>) => EXPECTED_ANY, EXPECTED_ANY> | undefined}
 		 */
 		this._cache = undefined;
 		/**
 		 * @private
-		 * @type {Map<Function, any> | undefined}
+		 * @template R
+		 * @type {Map<(set: SortableSet<T>) => EXPECTED_ANY, EXPECTED_ANY> | undefined}
 		 */
 		this._cacheOrderIndependent = undefined;
 	}
@@ -86,7 +88,7 @@ class SortableSet extends Set {
 			return;
 		}
 
-		const sortedArray = Array.from(this).sort(sortFn);
+		const sortedArray = [...this].sort(sortFn);
 		super.clear();
 		for (let i = 0; i < sortedArray.length; i += 1) {
 			super.add(sortedArray[i]);
@@ -102,8 +104,8 @@ class SortableSet extends Set {
 
 	/**
 	 * Get data from cache
-	 * @template R
-	 * @param {function(SortableSet<T>): R} fn function to calculate value
+	 * @template {EXPECTED_ANY} R
+	 * @param {(set: SortableSet<T>) => R} fn function to calculate value
 	 * @returns {R} returns result of fn(this), cached until set changes
 	 */
 	getFromCache(fn) {
@@ -124,7 +126,7 @@ class SortableSet extends Set {
 	/**
 	 * Get data from cache (ignoring sorting)
 	 * @template R
-	 * @param {function(SortableSet<T>): R} fn function to calculate value
+	 * @param {(set: SortableSet<T>) => R} fn function to calculate value
 	 * @returns {R} returns result of fn(this), cached until set changes
 	 */
 	getFromUnorderedCache(fn) {
@@ -166,7 +168,7 @@ class SortableSet extends Set {
 	 * @returns {T[]} the raw array
 	 */
 	toJSON() {
-		return Array.from(this);
+		return [...this];
 	}
 }
 

package/lib/util/StackedCacheMap.js

@@ -122,13 +122,13 @@ class StackedCacheMap {
 	 * @returns {Iterator<[K, V]>} iterator
 	 */
 	[Symbol.iterator]() {
-		const iterators = this.stack.map(map => map[Symbol.iterator]());
+		const iterators = this.stack.map((map) => map[Symbol.iterator]());
 		let current = this.map[Symbol.iterator]();
 		return {
 			next() {
 				let result = current.next();
 				while (result.done && iterators.length > 0) {
-					current = /** @type {IterableIterator<[K, V]>} */ (iterators.pop());
+					current = /** @type {MapIterator<[K, V]>} */ (iterators.pop());
 					result = current.next();
 				}
 				return result;

package/lib/util/StackedMap.js

@@ -24,7 +24,7 @@ const UNDEFINED_MARKER = Symbol("undefined");
  * @param {[K, InternalCell<V>]} pair the internal cell
  * @returns {[K, Cell<V>]} its “safe” representation
  */
-const extractPair = pair => {
+const extractPair = (pair) => {
 	const key = pair[0];
 	const val = pair[1];
 	if (val === UNDEFINED_MARKER || val === TOMBSTONE) {
@@ -45,7 +45,7 @@ class StackedMap {
 		/** @type {Map<K, InternalCell<V>>} */
 		this.map = new Map();
 		/** @type {Map<K, InternalCell<V>>[]} */
-		this.stack = parentStack === undefined ? [] : parentStack.slice();
+		this.stack = parentStack === undefined ? [] : [...parentStack];
 		this.stack.push(this.map);
 	}
 
@@ -134,7 +134,7 @@ class StackedMap {
 
 	asArray() {
 		this._compress();
-		return Array.from(this.map.keys());
+		return [...this.map.keys()];
 	}
 
 	asSet() {

package/lib/util/StringXor.js

@@ -36,7 +36,7 @@
  */
 class StringXor {
 	constructor() {
-		/** @type {Buffer|undefined} */
+		/** @type {Buffer | undefined} */
 		this._value = undefined;
 	}
 
@@ -71,6 +71,7 @@ class StringXor {
 			}
 		} else {
 			for (let i = 0; i < len; i++) {
+				// eslint-disable-next-line operator-assignment
 				value[i] = value[i] ^ str.charCodeAt(i);
 			}
 		}

package/lib/util/TupleQueue.js

@@ -8,21 +8,22 @@
 const TupleSet = require("./TupleSet");
 
 /**
- * @template {any[]} T
+ * @template T
+ * @template V
  */
 class TupleQueue {
 	/**
-	 * @param {Iterable<T>=} items The initial elements.
+	 * @param {Iterable<[T, V, ...EXPECTED_ANY]>=} items The initial elements.
 	 */
 	constructor(items) {
 		/**
 		 * @private
-		 * @type {TupleSet<T>}
+		 * @type {TupleSet<T, V>}
 		 */
 		this._set = new TupleSet(items);
 		/**
 		 * @private
-		 * @type {Iterator<T>}
+		 * @type {Iterator<[T, V, ...EXPECTED_ANY]>}
 		 */
 		this._iterator = this._set[Symbol.iterator]();
 	}
@@ -37,7 +38,7 @@ class TupleQueue {
 
 	/**
 	 * Appends the specified element to this queue.
-	 * @param {T} item The element to add.
+	 * @param {[T, V, ...EXPECTED_ANY]} item The element to add.
 	 * @returns {void}
 	 */
 	enqueue(...item) {
@@ -46,20 +47,22 @@ class TupleQueue {
 
 	/**
 	 * Retrieves and removes the head of this queue.
-	 * @returns {T | undefined} The head of the queue of `undefined` if this queue is empty.
+	 * @returns {[T, V, ...EXPECTED_ANY] | undefined} The head of the queue of `undefined` if this queue is empty.
 	 */
 	dequeue() {
 		const result = this._iterator.next();
 		if (result.done) {
 			if (this._set.size > 0) {
 				this._iterator = this._set[Symbol.iterator]();
-				const value = this._iterator.next().value;
+				const value =
+					/** @type {[T, V, ...EXPECTED_ANY]} */
+					(this._iterator.next().value);
 				this._set.delete(...value);
 				return value;
 			}
 			return;
 		}
-		this._set.delete(...result.value);
+		this._set.delete(.../** @type {[T, V, ...EXPECTED_ANY]} */ (result.value));
 		return result.value;
 	}
 }

package/lib/util/TupleSet.js

@@ -6,14 +6,21 @@
 "use strict";
 
 /**
- * @template {any[]} T
+ * @template K
+ * @template V
+ * @typedef {Map<K, InnerMap<K, V> | Set<V>>} InnerMap
+ */
+
+/**
+ * @template T
+ * @template V
  */
 class TupleSet {
 	/**
-	 * @param {Iterable<T>=} init init
+	 * @param {Iterable<[T, V, ...EXPECTED_ANY]>=} init init
 	 */
 	constructor(init) {
-		/** @type {Map<T, TODO>} */
+		/** @type {InnerMap<T, V>} */
 		this._map = new Map();
 		this.size = 0;
 		if (init) {
@@ -24,7 +31,7 @@ class TupleSet {
 	}
 
 	/**
-	 * @param  {T} args tuple
+	 * @param {[T, V, ...EXPECTED_ANY]} args tuple
 	 * @returns {void}
 	 */
 	add(...args) {
@@ -35,12 +42,12 @@ class TupleSet {
 			if (innerMap === undefined) {
 				map.set(arg, (map = new Map()));
 			} else {
-				map = innerMap;
+				map = /** @type {InnerMap<T, V>} */ (innerMap);
 			}
 		}
 
 		const beforeLast = args[args.length - 2];
-		let set = map.get(beforeLast);
+		let set = /** @type {Set<V>} */ (map.get(beforeLast));
 		if (set === undefined) {
 			map.set(beforeLast, (set = new Set()));
 		}
@@ -52,14 +59,14 @@ class TupleSet {
 	}
 
 	/**
-	 * @param  {T} args tuple
+	 * @param {[T, V, ...EXPECTED_ANY]} args tuple
 	 * @returns {boolean} true, if the tuple is in the Set
 	 */
 	has(...args) {
 		let map = this._map;
 		for (let i = 0; i < args.length - 2; i++) {
 			const arg = args[i];
-			map = map.get(arg);
+			map = /** @type {InnerMap<T, V>} */ (map.get(arg));
 			if (map === undefined) {
 				return false;
 			}
@@ -76,14 +83,14 @@ class TupleSet {
 	}
 
 	/**
-	 * @param {T} args tuple
+	 * @param {[T, V, ...EXPECTED_ANY]} args tuple
 	 * @returns {void}
 	 */
 	delete(...args) {
 		let map = this._map;
 		for (let i = 0; i < args.length - 2; i++) {
 			const arg = args[i];
-			map = map.get(arg);
+			map = /** @type {InnerMap<T, V>} */ (map.get(arg));
 			if (map === undefined) {
 				return;
 			}
@@ -102,26 +109,36 @@ class TupleSet {
 	}
 
 	/**
-	 * @returns {Iterator<T>} iterator
+	 * @returns {Iterator<[T, V, ...EXPECTED_ANY]>} iterator
 	 */
 	[Symbol.iterator]() {
-		/** @type {TODO[]} */
+		/**
+		 * @template T, V
+		 * @typedef {MapIterator<[T, InnerMap<T, V> | Set<V>]>} IteratorStack
+		 */
+
+		// This is difficult to type because we can have a map inside a map inside a map, etc. where the end is a set (each key is an argument)
+		// But in basic use we only have 2 arguments in our methods, so we have `Map<K, Set<V>>`
+		/** @type {IteratorStack<T, V>[]} */
 		const iteratorStack = [];
-		/** @type {T[]} */
+		/** @type {[T?, V?, ...EXPECTED_ANY]} */
 		const tuple = [];
-		/** @type {Iterator<T> | undefined} */
+		/** @type {SetIterator<V> | undefined} */
 		let currentSetIterator;
 
 		/**
-		 * @param {TODO} it iterator
+		 * @param {IteratorStack<T, V>} it iterator
 		 * @returns {boolean} result
 		 */
-		const next = it => {
+		const next = (it) => {
 			const result = it.next();
 			if (result.done) {
 				if (iteratorStack.length === 0) return false;
 				tuple.pop();
-				return next(iteratorStack.pop());
+				return next(
+					/** @type {IteratorStack<T, V>} */
+					(iteratorStack.pop())
+				);
 			}
 			const [key, value] = result.value;
 			iteratorStack.push(it);
@@ -141,13 +158,21 @@ class TupleSet {
 					const result = currentSetIterator.next();
 					if (result.done) {
 						tuple.pop();
-						if (!next(iteratorStack.pop())) {
+						if (
+							!next(
+								/** @type {IteratorStack<T, V>} */
+								(iteratorStack.pop())
+							)
+						) {
 							currentSetIterator = undefined;
 						}
 					} else {
 						return {
 							done: false,
-							value: /** @type {T} */ (tuple.concat(result.value))
+							value:
+								/* eslint-disable unicorn/prefer-spread */
+								/** @type {[T, V, ...EXPECTED_ANY]} */
+								(tuple.concat(result.value))
 						};
 					}
 				}

package/lib/util/URLAbsoluteSpecifier.js

@@ -5,8 +5,7 @@
 
 "use strict";
 
-/** @typedef {import("./fs").InputFileSystem} InputFileSystem */
-/** @typedef {(error: Error|null, result?: Buffer) => void} ErrorFirstCallback */
+/** @typedef {(error: Error | null, result?: Buffer) => void} ErrorFirstCallback */
 
 const backSlashCharCode = "\\".charCodeAt(0);
 const slashCharCode = "/".charCodeAt(0);
@@ -26,7 +25,7 @@ const queryCharCode = "?".charCodeAt(0);
  * e.g. Absolute specifiers like 'file:///user/webpack/index.js'
  * https://tools.ietf.org/html/rfc3986#section-3.1
  * @param {string} specifier specifier
- * @returns {string|undefined} scheme if absolute URL specifier provided
+ * @returns {string | undefined} scheme if absolute URL specifier provided
  */
 function getScheme(specifier) {
 	const start = specifier.charCodeAt(0);
@@ -83,5 +82,5 @@ function getProtocol(specifier) {
 	return scheme === undefined ? undefined : `${scheme}:`;
 }
 
-module.exports.getScheme = getScheme;
 module.exports.getProtocol = getProtocol;
+module.exports.getScheme = getScheme;