webpack 5.98.0 → 5.99.0

package/lib/util/LazyBucketSortedSet.js

@@ -10,12 +10,25 @@ const SortableSet = require("./SortableSet");
 
 /**
  * @template T
- * @typedef {LazyBucketSortedSet<T, any> | SortableSet<T>} Entry
+ * @template K
+ * @typedef {(item: T) => K} GetKey
+ */
+
+/**
+ * @template T
+ * @typedef {(a: T, n: T) => number} Comparator
  */
 
 /**
  * @template T
- * @typedef {(function(T): any) | (function(any, any): number)} Arg
+ * @template K
+ * @typedef {LazyBucketSortedSet<T, K> | SortableSet<T>} Entry
+ */
+
+/**
+ * @template T
+ * @template K
+ * @typedef {GetKey<T, K> | Comparator<K> | Comparator<T>} Arg
  */
 
 /**
@@ -32,17 +45,16 @@ const SortableSet = require("./SortableSet");
  */
 class LazyBucketSortedSet {
 	/**
-	 * @param {function(T): K} getKey function to get key from item
-	 * @param {function(K, K): number} comparator comparator to sort keys
-	 * @param  {...Arg<T>} args more pairs of getKey and comparator plus optional final comparator for the last layer
+	 * @param {GetKey<T, K>} getKey function to get key from item
+	 * @param {Comparator<K>=} comparator comparator to sort keys
+	 * @param {...Arg<T, K>} args more pairs of getKey and comparator plus optional final comparator for the last layer
 	 */
 	constructor(getKey, comparator, ...args) {
 		this._getKey = getKey;
-		/** @type {Arg<T>[]} */
 		this._innerArgs = args;
 		this._leaf = args.length <= 1;
 		this._keys = new SortableSet(undefined, comparator);
-		/** @type {Map<K, Entry<T>>} */
+		/** @type {Map<K, Entry<T, K>>} */
 		this._map = new Map();
 		this._unsortedItems = new Set();
 		this.size = 0;
@@ -65,18 +77,20 @@ class LazyBucketSortedSet {
 	_addInternal(key, item) {
 		let entry = this._map.get(key);
 		if (entry === undefined) {
-			entry =
-				/** @type {Entry<T>} */
-				(
-					this._leaf
-						? new SortableSet(undefined, this._innerArgs[0])
-						: new /** @type {TODO} */ (LazyBucketSortedSet)(...this._innerArgs)
-				);
+			entry = this._leaf
+				? new SortableSet(
+						undefined,
+						/** @type {Comparator<T>} */
+						(this._innerArgs[0])
+					)
+				: new LazyBucketSortedSet(
+						.../** @type {[GetKey<T, K>, Comparator<K>]} */
+						(this._innerArgs)
+					);
 			this._keys.add(key);
 			this._map.set(key, entry);
 		}
-		/** @type {Entry<T>} */
-		(entry).add(item);
+		entry.add(item);
 	}
 
 	/**
@@ -90,7 +104,7 @@ class LazyBucketSortedSet {
 			return;
 		}
 		const key = this._getKey(item);
-		const entry = /** @type {Entry<T>} */ (this._map.get(key));
+		const entry = /** @type {Entry<T, K>} */ (this._map.get(key));
 		entry.delete(item);
 		if (entry.size === 0) {
 			this._deleteKey(key);
@@ -132,7 +146,9 @@ class LazyBucketSortedSet {
 			}
 			return item;
 		}
-		const nodeEntry = /** @type {LazyBucketSortedSet<T, any>} */ (entry);
+		const nodeEntry =
+			/** @type {LazyBucketSortedSet<T, K>} */
+			(entry);
 		const item = nodeEntry.popFirst();
 		if (nodeEntry.size === 0) {
 			this._deleteKey(key);
@@ -142,7 +158,7 @@ class LazyBucketSortedSet {
 
 	/**
 	 * @param {T} item to be updated item
-	 * @returns {function(true=): void} finish update
+	 * @returns {(remove?: true) => void} finish update
 	 */
 	startUpdate(item) {
 		if (this._unsortedItems.has(item)) {
@@ -178,9 +194,9 @@ class LazyBucketSortedSet {
 				}
 			};
 		}
-		const oldEntry = /** @type {LazyBucketSortedSet<T, any>} */ (
-			this._map.get(key)
-		);
+		const oldEntry =
+			/** @type {LazyBucketSortedSet<T, K>} */
+			(this._map.get(key));
 		const finishUpdate = oldEntry.startUpdate(item);
 		return remove => {
 			if (remove) {
@@ -218,7 +234,9 @@ class LazyBucketSortedSet {
 				const iterator = leafEntry[Symbol.iterator]();
 				iterators.push(iterator);
 			} else {
-				const nodeEntry = /** @type {LazyBucketSortedSet<T, any>} */ (entry);
+				const nodeEntry =
+					/** @type {LazyBucketSortedSet<T, K>} */
+					(entry);
 				nodeEntry._appendIterators(iterators);
 			}
 		}

package/lib/util/LazySet.js

@@ -148,8 +148,9 @@ 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) {

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() {

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

@@ -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) => {

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;
 	}
@@ -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) {

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]>=} 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]>}
 		 */
 		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]} item The element to add.
 	 * @returns {void}
 	 */
 	enqueue(...item) {
@@ -46,20 +47,20 @@ 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] | 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]} */ (this._iterator.next().value);
 				this._set.delete(...value);
 				return value;
 			}
 			return;
 		}
-		this._set.delete(...result.value);
+		this._set.delete(.../** @type {[T, V]} */ (result.value));
 		return result.value;
 	}
 }

package/lib/util/TupleSet.js

@@ -24,7 +24,7 @@ class TupleSet {
 	}
 
 	/**
-	 * @param  {T} args tuple
+	 * @param {T} args tuple
 	 * @returns {void}
 	 */
 	add(...args) {
@@ -52,7 +52,7 @@ class TupleSet {
 	}
 
 	/**
-	 * @param  {T} args tuple
+	 * @param {T} args tuple
 	 * @returns {boolean} true, if the tuple is in the Set
 	 */
 	has(...args) {

package/lib/util/WeakTupleMap.js

@@ -6,18 +6,19 @@
 "use strict";
 
 /**
- * @template {any[]} T
+ * @template T
  * @template V
- * @typedef {Map<object, WeakTupleMap<T, V>>} M
+ * @typedef {Map<EXPECTED_ANY, WeakTupleMap<T[], V>>} M
  */
+
 /**
- * @template {any[]} T
+ * @template T
  * @template V
- * @typedef {WeakMap<object, WeakTupleMap<T, V>>} W
+ * @typedef {WeakMap<EXPECTED_OBJECT, WeakTupleMap<T[], V>>} W
  */
 
 /**
- * @param {any} thing thing
+ * @param {EXPECTED_ANY} thing thing
  * @returns {boolean} true if is weak
  */
 const isWeakKey = thing => typeof thing === "object" && thing !== null;
@@ -32,7 +33,7 @@ class WeakTupleMap {
 		this.f = 0;
 		/**
 		 * @private
-		 * @type {any}
+		 * @type {V | undefined}
 		 */
 		this.v = undefined;
 		/**
@@ -89,7 +90,7 @@ class WeakTupleMap {
 	}
 
 	/**
-	 * @param {[...T, function(): V]} args tuple
+	 * @param {[...T, () => V]} args tuple
 	 * @returns {V} the value
 	 */
 	provide(...args) {
@@ -98,7 +99,7 @@ class WeakTupleMap {
 		for (let i = 0; i < args.length - 1; i++) {
 			node = node._get(args[i]);
 		}
-		if (node._hasValue()) return node._getValue();
+		if (node._hasValue()) return /** @type {V} */ (node._getValue());
 		const fn = args[args.length - 1];
 		const newValue = fn(...args.slice(0, -1));
 		node._setValue(newValue);
@@ -138,7 +139,7 @@ class WeakTupleMap {
 	}
 
 	/**
-	 * @param {any} v value
+	 * @param {V} v value
 	 * @private
 	 */
 	_setValue(v) {
@@ -152,7 +153,7 @@ class WeakTupleMap {
 	}
 
 	/**
-	 * @param {any} thing thing
+	 * @param {EXPECTED_ANY} thing thing
 	 * @returns {WeakTupleMap<T, V> | undefined} thing
 	 * @private
 	 */
@@ -167,7 +168,7 @@ class WeakTupleMap {
 
 	/**
 	 * @private
-	 * @param {any} thing thing
+	 * @param {EXPECTED_ANY} thing thing
 	 * @returns {WeakTupleMap<T, V>} value
 	 */
 	_get(thing) {

package/lib/util/binarySearchBounds.js

@@ -69,11 +69,12 @@ const compileSearch = (funcName, predicate, reversed, extraArgs, earlyOut) => {
  * A(): Performs a binary search on an array using the comparison operator specified.
  * P(): Performs a binary search on an array using a _custom comparison function_
  * `c(x,y)` **and** comparison operator specified by `predicate`.
+ * @template T
  * @param {BinarySearchPredicate} predicate The predicate / comparison operator to be used in the binary search.
  * @param {boolean} reversed Whether the search should be reversed.
  * @param {SearchPredicateSuffix} suffix The suffix to be used in the function name.
  * @param {boolean=} earlyOut Whether the search should return as soon as a match is found.
- * @returns {Function} The compiled binary search function.
+ * @returns {(items: T[], start: number, compareFn?: number | ((item: T, needle: number) => number), l?: number, h?: number) => number} The compiled binary search function.
  */
 const compileBoundsSearch = (predicate, reversed, suffix, earlyOut) => {
 	const arg1 = compileSearch("A", `x${predicate}y`, reversed, ["y"], earlyOut);