webpack 5.97.1 → 5.104.1

package/lib/util/WeakTupleMap.js

@@ -6,24 +6,30 @@
 "use strict";
 
 /**
- * @template {any[]} T
+ * @template {EXPECTED_ANY[]} T
  * @template V
- * @typedef {Map<object, WeakTupleMap<T, V>>} M
+ * @typedef {Map<EXPECTED_ANY, WeakTupleMap<T, V>>} M
  */
+
 /**
- * @template {any[]} T
+ * @template {EXPECTED_ANY[]} 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;
+const isWeakKey = (thing) => typeof thing === "object" && thing !== null;
+
+/**
+ * @template {unknown[]} T
+ * @typedef {T extends ReadonlyArray<infer ElementType> ? ElementType : never} ArrayElement
+ */
 
 /**
- * @template {any[]} T
+ * @template {EXPECTED_ANY[]} K
  * @template V
  */
 class WeakTupleMap {
@@ -32,88 +38,88 @@ class WeakTupleMap {
 		this.f = 0;
 		/**
 		 * @private
-		 * @type {any}
+		 * @type {V | undefined}
 		 */
 		this.v = undefined;
 		/**
 		 * @private
-		 * @type {M<T, V> | undefined}
+		 * @type {M<K, V> | undefined}
 		 */
 		this.m = undefined;
 		/**
 		 * @private
-		 * @type {W<T, V> | undefined}
+		 * @type {W<K, V> | undefined}
 		 */
 		this.w = undefined;
 	}
 
 	/**
-	 * @param {[...T, V]} args tuple
+	 * @param {[...K, V]} args tuple
 	 * @returns {void}
 	 */
 	set(...args) {
-		/** @type {WeakTupleMap<T, V>} */
+		/** @type {WeakTupleMap<K, V>} */
 		let node = this;
 		for (let i = 0; i < args.length - 1; i++) {
-			node = node._get(args[i]);
+			node = node._get(/** @type {ArrayElement<K>} */ (args[i]));
 		}
-		node._setValue(args[args.length - 1]);
+		node._setValue(/** @type {V} */ (args[args.length - 1]));
 	}
 
 	/**
-	 * @param {T} args tuple
+	 * @param {K} args tuple
 	 * @returns {boolean} true, if the tuple is in the Set
 	 */
 	has(...args) {
-		/** @type {WeakTupleMap<T, V> | undefined} */
+		/** @type {WeakTupleMap<K, V> | undefined} */
 		let node = this;
 		for (let i = 0; i < args.length; i++) {
-			node = node._peek(args[i]);
+			node = node._peek(/** @type {ArrayElement<K>} */ (args[i]));
 			if (node === undefined) return false;
 		}
 		return node._hasValue();
 	}
 
 	/**
-	 * @param {T} args tuple
+	 * @param {K} args tuple
 	 * @returns {V | undefined} the value
 	 */
 	get(...args) {
-		/** @type {WeakTupleMap<T, V> | undefined} */
+		/** @type {WeakTupleMap<K, V> | undefined} */
 		let node = this;
 		for (let i = 0; i < args.length; i++) {
-			node = node._peek(args[i]);
+			node = node._peek(/** @type {ArrayElement<K>} */ (args[i]));
 			if (node === undefined) return;
 		}
 		return node._getValue();
 	}
 
 	/**
-	 * @param {[...T, function(): V]} args tuple
+	 * @param {[...K, (...args: K) => V]} args tuple
 	 * @returns {V} the value
 	 */
 	provide(...args) {
-		/** @type {WeakTupleMap<T, V>} */
+		/** @type {WeakTupleMap<K, V>} */
 		let node = this;
 		for (let i = 0; i < args.length - 1; i++) {
-			node = node._get(args[i]);
+			node = node._get(/** @type {ArrayElement<K>} */ (args[i]));
 		}
-		if (node._hasValue()) return node._getValue();
-		const fn = args[args.length - 1];
-		const newValue = fn(...args.slice(0, -1));
+		if (node._hasValue()) return /** @type {V} */ (node._getValue());
+		const fn = /** @type {(...args: K) => V} */ (args[args.length - 1]);
+		const newValue = fn(.../** @type {K} */ (args.slice(0, -1)));
 		node._setValue(newValue);
 		return newValue;
 	}
 
 	/**
-	 * @param {T} args tuple
+	 * @param {K} args tuple
 	 * @returns {void}
 	 */
 	delete(...args) {
-		/** @type {WeakTupleMap<T, V> | undefined} */
+		/** @type {WeakTupleMap<K, V> | undefined} */
 		let node = this;
 		for (let i = 0; i < args.length; i++) {
-			node = node._peek(args[i]);
+			node = node._peek(/** @type {ArrayElement<K>} */ (args[i]));
 			if (node === undefined) return;
 		}
 		node._deleteValue();
@@ -138,7 +144,7 @@ class WeakTupleMap {
 	}
 
 	/**
-	 * @param {any} v value
+	 * @param {V} v value
 	 * @private
 	 */
 	_setValue(v) {
@@ -152,59 +158,67 @@ class WeakTupleMap {
 	}
 
 	/**
-	 * @param {any} thing thing
-	 * @returns {WeakTupleMap<T, V> | undefined} thing
+	 * @param {ArrayElement<K>} thing thing
+	 * @returns {WeakTupleMap<K, V> | undefined} thing
 	 * @private
 	 */
 	_peek(thing) {
 		if (isWeakKey(thing)) {
 			if ((this.f & 4) !== 4) return;
-			return /** @type {W<T, V>} */ (this.w).get(thing);
+			return /** @type {WeakMap<ArrayElement<K>, WeakTupleMap<K, V>>} */ (
+				this.w
+			).get(thing);
 		}
 		if ((this.f & 2) !== 2) return;
-		return /** @type {M<T, V>} */ (this.m).get(thing);
+		return /** @type {Map<ArrayElement<K>, WeakTupleMap<K, V>>} */ (this.m).get(
+			thing
+		);
 	}
 
 	/**
 	 * @private
-	 * @param {any} thing thing
-	 * @returns {WeakTupleMap<T, V>} value
+	 * @param {ArrayElement<K>} thing thing
+	 * @returns {WeakTupleMap<K, V>} value
 	 */
 	_get(thing) {
 		if (isWeakKey(thing)) {
 			if ((this.f & 4) !== 4) {
+				/** @type {W<K, V>} */
 				const newMap = new WeakMap();
 				this.f |= 4;
+				/** @type {WeakTupleMap<K, V>} */
 				const newNode = new WeakTupleMap();
 				(this.w = newMap).set(thing, newNode);
 				return newNode;
 			}
-			const entry =
-				/** @type {W<T, V>} */
-				(this.w).get(thing);
+			const entry = /** @type {W<K, V>} */ (this.w).get(thing);
 			if (entry !== undefined) {
 				return entry;
 			}
+			/** @type {WeakTupleMap<K, V>} */
 			const newNode = new WeakTupleMap();
-			/** @type {W<T, V>} */
+			/** @type {W<K, V>} */
 			(this.w).set(thing, newNode);
 			return newNode;
 		}
 		if ((this.f & 2) !== 2) {
+			/** @type {M<K, V>} */
 			const newMap = new Map();
 			this.f |= 2;
+			/** @type {WeakTupleMap<K, V>} */
 			const newNode = new WeakTupleMap();
 			(this.m = newMap).set(thing, newNode);
 			return newNode;
 		}
 		const entry =
-			/** @type {M<T, V>} */
+			/** @type {M<K, V>} */
 			(this.m).get(thing);
 		if (entry !== undefined) {
 			return entry;
 		}
+		/** @type {WeakTupleMap<K, V>} */
 		const newNode = new WeakTupleMap();
-		/** @type {M<T, V>} */
+		/** @type {M<K, V>} */
 		(this.m).set(thing, newNode);
 		return newNode;
 	}

package/lib/util/binarySearchBounds.js

@@ -8,8 +8,8 @@
 /* cspell:disable-next-line */
 // Refactor: Peter Somogyvari @petermetz
 
-/** @typedef {">=" | "<=" | "<" | ">" | "-" } BinarySearchPredicate */
-/** @typedef {"GE" | "GT" | "LT" | "LE" | "EQ" } SearchPredicateSuffix */
+/** @typedef {">=" | "<=" | "<" | ">" | "-"} BinarySearchPredicate */
+/** @typedef {"GE" | "GT" | "LT" | "LE" | "EQ"} SearchPredicateSuffix */
 
 /**
  * Helper function for compiling binary search functions.
@@ -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);

package/lib/util/chainedImports.js

@@ -10,6 +10,8 @@
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
+/** @typedef {Range[]} IdRanges */
+
 /**
  * @summary Get the subset of ids and their corresponding range in an id chain that should be re-rendered by webpack.
  * Only those in the chain that are actually referring to namespaces or imports should be re-rendered.
@@ -18,7 +20,7 @@
  * because minifiers treat quoted accessors differently.  e.g. import { a } from "./module"; a["b"] vs a.b
  * @param {string[]} untrimmedIds chained ids
  * @param {Range} untrimmedRange range encompassing allIds
- * @param {Range[] | undefined} ranges cumulative range of ids for each of allIds
+ * @param {IdRanges | undefined} ranges cumulative range of ids for each of allIds
  * @param {ModuleGraph} moduleGraph moduleGraph
  * @param {Dependency} dependency dependency
  * @returns {{trimmedIds: string[], trimmedRange: Range}} computed trimmed ids and cumulative range of those ids