webpack 5.111.1 → 5.112.1

package/lib/util/TupleSet.js

@@ -16,16 +16,16 @@
 /**
  * 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 {EXPECTED_ANY[]} K
  * @template V
  */
 class TupleSet {
 	/**
 	 * Seeds the tuple set with an optional iterable of tuples.
-	 * @param {Iterable<[T, V, ...EXPECTED_ANY]>=} init init
+	 * @param {Iterable<[...K, V]>=} init init
 	 */
 	constructor(init) {
-		/** @type {InnerMap<T, V>} */
+		/** @type {InnerMap<K[number], V>} */
 		this._map = new Map();
 		/** @type {number} */
 		this.size = 0;
@@ -38,28 +38,28 @@ class TupleSet {
 
 	/**
 	 * Adds a tuple to the set, creating any missing prefix maps along the way.
-	 * @param {[T, V, ...EXPECTED_ANY]} args tuple
+	 * @param {[...K, V]} args tuple
 	 * @returns {void}
 	 */
 	add(...args) {
 		let map = this._map;
 		for (let i = 0; i < args.length - 2; i++) {
-			const arg = args[i];
+			const arg = /** @type {K[number]} */ (args[i]);
 			const innerMap = map.get(arg);
 			if (innerMap === undefined) {
 				map.set(arg, (map = new Map()));
 			} else {
-				map = /** @type {InnerMap<T, V>} */ (innerMap);
+				map = /** @type {InnerMap<K[number], V>} */ (innerMap);
 			}
 		}
 
-		const beforeLast = args[args.length - 2];
+		const beforeLast = /** @type {K[number]} */ (args[args.length - 2]);
 		let set = /** @type {Set<V>} */ (map.get(beforeLast));
 		if (set === undefined) {
 			map.set(beforeLast, (set = new Set()));
 		}
 
-		const last = args[args.length - 1];
+		const last = /** @type {V} */ (args[args.length - 1]);
 		this.size -= set.size;
 		set.add(last);
 		this.size += set.size;
@@ -67,51 +67,51 @@ class TupleSet {
 
 	/**
 	 * Checks whether the exact tuple is already present in the set.
-	 * @param {[T, V, ...EXPECTED_ANY]} args tuple
+	 * @param {[...K, V]} 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 = /** @type {InnerMap<T, V>} */ (map.get(arg));
+			const arg = /** @type {K[number]} */ (args[i]);
+			map = /** @type {InnerMap<K[number], V>} */ (map.get(arg));
 			if (map === undefined) {
 				return false;
 			}
 		}
 
-		const beforeLast = args[args.length - 2];
-		const set = map.get(beforeLast);
+		const beforeLast = /** @type {K[number]} */ (args[args.length - 2]);
+		const set = /** @type {Set<V> | undefined} */ (map.get(beforeLast));
 		if (set === undefined) {
 			return false;
 		}
 
-		const last = args[args.length - 1];
+		const last = /** @type {V} */ (args[args.length - 1]);
 		return set.has(last);
 	}
 
 	/**
 	 * Removes a tuple from the set when it is present.
-	 * @param {[T, V, ...EXPECTED_ANY]} args tuple
+	 * @param {[...K, V]} args tuple
 	 * @returns {void}
 	 */
 	delete(...args) {
 		let map = this._map;
 		for (let i = 0; i < args.length - 2; i++) {
-			const arg = args[i];
-			map = /** @type {InnerMap<T, V>} */ (map.get(arg));
+			const arg = /** @type {K[number]} */ (args[i]);
+			map = /** @type {InnerMap<K[number], V>} */ (map.get(arg));
 			if (map === undefined) {
 				return;
 			}
 		}
 
-		const beforeLast = args[args.length - 2];
-		const set = map.get(beforeLast);
+		const beforeLast = /** @type {K[number]} */ (args[args.length - 2]);
+		const set = /** @type {Set<V> | undefined} */ (map.get(beforeLast));
 		if (set === undefined) {
 			return;
 		}
 
-		const last = args[args.length - 1];
+		const last = /** @type {V} */ (args[args.length - 1]);
 		this.size -= set.size;
 		set.delete(last);
 		this.size += set.size;
@@ -120,7 +120,7 @@ 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
+	 * @returns {Iterator<[...K, V]>} iterator
 	 */
 	[Symbol.iterator]() {
 		/**
@@ -131,9 +131,9 @@ class TupleSet {
 
 		// 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>[]} */
+		/** @type {IteratorStack<K[number], V>[]} */
 		const iteratorStack = [];
-		/** @type {[T?, V?, ...EXPECTED_ANY]} */
+		/** @type {(K[number] | V)[]} */
 		const tuple = [];
 		/** @type {SetIterator<V> | undefined} */
 		let currentSetIterator;
@@ -141,7 +141,7 @@ class TupleSet {
 		/**
 		 * Advances through nested maps until a terminal value set is reached or
 		 * every remaining branch has been exhausted.
-		 * @param {IteratorStack<T, V>} it iterator
+		 * @param {IteratorStack<K[number], V>} it iterator
 		 * @returns {boolean} result
 		 */
 		const next = (it) => {
@@ -150,7 +150,7 @@ class TupleSet {
 				if (iteratorStack.length === 0) return false;
 				tuple.pop();
 				return next(
-					/** @type {IteratorStack<T, V>} */
+					/** @type {IteratorStack<K[number], V>} */
 					(iteratorStack.pop())
 				);
 			}
@@ -174,7 +174,7 @@ class TupleSet {
 						tuple.pop();
 						if (
 							!next(
-								/** @type {IteratorStack<T, V>} */
+								/** @type {IteratorStack<K[number], V>} */
 								(iteratorStack.pop())
 							)
 						) {
@@ -185,7 +185,7 @@ class TupleSet {
 							done: false,
 							value:
 								/* eslint-disable unicorn/prefer-spread */
-								/** @type {[T, V, ...EXPECTED_ANY]} */
+								/** @type {[...K, V]} */
 								(tuple.concat(result.value))
 						};
 					}

package/lib/util/WeakTupleMap.js

@@ -5,39 +5,46 @@
 
 "use strict";
 
+/**
+ * A value one position of a tuple key may hold: a primitive kept in a `Map`, or
+ * an object (functions included) kept in a `WeakMap`.
+ * @typedef {string | number | bigint | boolean | symbol | EXPECTED_OBJECT | null | undefined} TupleElement
+ */
+
 /**
  * Strong-key child map used for tuple elements that cannot be stored in a
  * `WeakMap`.
- * @template {EXPECTED_ANY[]} T
+ * @template {TupleElement[]} T
  * @template V
- * @typedef {Map<EXPECTED_ANY, WeakTupleMap<T, V>>} M
+ * @typedef {Map<ArrayElement<T>, WeakTupleMap<T, V>>} M
  */
 
 /**
  * Weak-key child map used for tuple elements that are objects and can be held
  * without preventing garbage collection.
- * @template {EXPECTED_ANY[]} T
+ * @template {TupleElement[]} T
  * @template V
- * @typedef {WeakMap<EXPECTED_OBJECT, WeakTupleMap<T, V>>} W
+ * @typedef {WeakMap<ArrayElement<T> & EXPECTED_OBJECT, WeakTupleMap<T, V>>} W
  */
 
 /**
  * Reports whether a tuple element can be stored in a `WeakMap`.
- * @param {EXPECTED_ANY} thing thing
- * @returns {boolean} true if is weak
+ * @template T
+ * @param {T} thing thing
+ * @returns {thing is T & EXPECTED_OBJECT} true if is weak
  */
 const isWeakKey = (thing) => typeof thing === "object" && thing !== null;
 
 /**
  * Extracts the element type from a tuple-like array.
- * @template {unknown[]} T
+ * @template T
  * @typedef {T extends ReadonlyArray<infer ElementType> ? ElementType : never} ArrayElement
  */
 
 /**
  * Stores values by tuple keys while using `WeakMap` for object elements so the
  * cache can release entries when those objects are collected.
- * @template {EXPECTED_ANY[]} K
+ * @template {TupleElement[]} K
  * @template V
  */
 class WeakTupleMap {
@@ -136,8 +143,9 @@ class WeakTupleMap {
 	 * () => compute(thisArg, ...args))` but without allocating that closure (or an
 	 * extra rest array) on every call — `ModuleGraph#cached` runs this on hot
 	 * paths where most calls hit the cache and the closure would be pure waste.
-	 * @param {(thisArg: EXPECTED_ANY, ...args: K) => V} compute computer, also the first key element
-	 * @param {EXPECTED_ANY} thisArg first argument passed to `compute`
+	 * @template This
+	 * @param {(thisArg: This, ...args: K) => V} compute computer, also the first key element
+	 * @param {This} thisArg first argument passed to `compute`
 	 * @param {K} args remaining key elements, also passed to `compute`
 	 * @returns {V} the value
 	 */
@@ -222,14 +230,10 @@ class WeakTupleMap {
 	_peek(thing) {
 		if (isWeakKey(thing)) {
 			if ((this.f & 4) !== 4) return;
-			return /** @type {WeakMap<ArrayElement<K>, WeakTupleMap<K, V>>} */ (
-				this.w
-			).get(thing);
+			return /** @type {W<K, V>} */ (this.w).get(thing);
 		}
 		if ((this.f & 2) !== 2) return;
-		return /** @type {Map<ArrayElement<K>, WeakTupleMap<K, V>>} */ (this.m).get(
-			thing
-		);
+		return /** @type {M<K, V>} */ (this.m).get(thing);
 	}
 
 	/**

package/lib/util/buildDiagnostics.js

@@ -5,8 +5,8 @@
 
 "use strict";
 
-/** @import Module, { BuildDiagnostics, BuildInfo } from "../Module" */
-/** @import ModuleGraph from "../ModuleGraph" */
+/** @import Module, { BuildDiagnostics, BuildInfo } from "../module/Module" */
+/** @import ModuleGraph from "../graph/ModuleGraph" */
 
 /**
  * The diagnostics record of a build info, created on first use so a module nothing reports about carries none.

package/lib/util/cleverMerge.js

@@ -88,19 +88,27 @@ const cachedSetProperty = (obj, property, value) => {
 
 /**
  * Defines the by values type used by this module.
- * @typedef {Map<string, EXPECTED_ANY>} ByValues
+ * @template V
+ * @typedef {Map<string, V>} ByValues
  */
 
 /**
  * Defines the object parsed property entry type used by this module.
  * @template T
+ * @template [V=T[keyof T]]
  * @typedef {object} ObjectParsedPropertyEntry
- * @property {T[keyof T] | undefined} base base value
+ * @property {V | undefined} base base value
  * @property {`by${string}` | undefined} byProperty the name of the selector property
- * @property {ByValues | undefined} byValues value depending on selector property, merged with base
+ * @property {ByValues<V | undefined> | undefined} byValues value depending on selector property, merged with base
  */
 
-/** @typedef {((...x: EXPECTED_ANY) => object) & { [DYNAMIC_INFO]: [DynamicFunction, object] }} DynamicFunction */
+/**
+ * Result of merging a value of type `A` with a value of type `B`.
+ * @template A, B
+ * @typedef {A & B | (A | B)[] | A | A[] | B | B[]} MergedValue
+ */
+
+/** @typedef {((...values: never[]) => object) & { [DYNAMIC_INFO]: [DynamicFunction, object] }} DynamicFunction */
 
 /**
  * Defines the parsed object static type used by this module.
@@ -139,7 +147,11 @@ const cachedParseObject = (obj) => {
 	return result;
 };
 
-/** @typedef {{ [p: string]: { [p: string]: EXPECTED_ANY } } | DynamicFunction} ByObject */
+/**
+ * Defines the by object type used by this module.
+ * @template T
+ * @typedef {{ [p: string]: Partial<T> } | DynamicFunction} ByObject
+ */
 
 /**
  * Returns parsed object.
@@ -172,7 +184,7 @@ const parseObject = (obj) => {
 		const key = /** @type {keyof T} */ (key_);
 		if (typeof key === "string" && key.startsWith("by")) {
 			const byProperty = key;
-			const byObj = /** @type {ByObject} */ (obj[byProperty]);
+			const byObj = /** @type {ByObject<T>} */ (obj[byProperty]);
 			if (typeof byObj === "object") {
 				for (const byValue of Object.keys(byObj)) {
 					const obj = byObj[/** @type {keyof (keyof T)} */ (byValue)];
@@ -183,20 +195,20 @@ const parseObject = (obj) => {
 							entry.byValues = new Map();
 						} else if (entry.byProperty !== byProperty) {
 							throw new Error(
-								`${/** @type {string} */ (byProperty)} and ${entry.byProperty} for a single property is not supported`
+								`${byProperty} and ${entry.byProperty} for a single property is not supported`
 							);
 						}
-						/** @type {ByValues} */
-						(entry.byValues).set(byValue, obj[key]);
+						/** @type {ByValues<T[keyof T] | undefined>} */
+						(entry.byValues).set(byValue, obj[/** @type {keyof T} */ (key)]);
 						if (byValue === "default") {
 							for (const otherByValue of Object.keys(byObj)) {
 								if (
 									!(
-										/** @type {ByValues} */
+										/** @type {ByValues<T[keyof T] | undefined>} */
 										(entry.byValues).has(otherByValue)
 									)
 								) {
-									/** @type {ByValues} */
+									/** @type {ByValues<T[keyof T] | undefined>} */
 									(entry.byValues).set(otherByValue, undefined);
 								}
 							}
@@ -237,13 +249,19 @@ const parseObject = (obj) => {
  * @returns {T} the object
  */
 const serializeObject = (info, dynamicInfo) => {
-	const obj = /** @type {EXPECTED_ANY} */ ({});
+	const obj =
+		/** @type {Record<PropertyKey, T[keyof T] | Record<string, Record<PropertyKey, T[keyof T]>> | DynamicFunction>} */
+		({});
 	// Setup byProperty structure
 	for (const entry of info.values()) {
 		if (entry.byProperty !== undefined) {
 			const byProperty = entry.byProperty;
-			const byObj = (obj[byProperty] = obj[byProperty] || {});
-			for (const byValue of /** @type {ByValues} */ (entry.byValues).keys()) {
+			const byObj =
+				/** @type {Record<string, Record<PropertyKey, T[keyof T]>>} */
+				(obj[byProperty] = obj[byProperty] || {});
+			for (const byValue of /** @type {ByValues<T[keyof T] | undefined>} */ (
+				entry.byValues
+			).keys()) {
 				byObj[byValue] = byObj[byValue] || {};
 			}
 		}
@@ -255,10 +273,12 @@ const serializeObject = (info, dynamicInfo) => {
 		// Fill byProperty structure
 		if (entry.byProperty !== undefined) {
 			const byProperty = entry.byProperty;
-			const byObj = (obj[byProperty] = obj[byProperty] || {});
+			const byObj =
+				/** @type {Record<string, Record<PropertyKey, T[keyof T]>>} */
+				(obj[byProperty] = obj[byProperty] || {});
 			for (const byValue of Object.keys(byObj)) {
 				const value = getFromByValues(
-					/** @type {ByValues} */
+					/** @type {ByValues<T[keyof T] | undefined>} */
 					(entry.byValues),
 					byValue
 				);
@@ -269,7 +289,7 @@ const serializeObject = (info, dynamicInfo) => {
 	if (dynamicInfo !== undefined) {
 		obj[dynamicInfo.byProperty] = dynamicInfo.fn;
 	}
-	return obj;
+	return /** @type {T} */ (obj);
 };
 
 const VALUE_TYPE_UNDEFINED = 0;
@@ -395,7 +415,7 @@ const _cleverMerge = (first, second, internalCaching = false) => {
  * @param {ObjectParsedPropertyEntry<T>} firstEntry a
  * @param {ObjectParsedPropertyEntry<O>} secondEntry b
  * @param {boolean} internalCaching should parsing of objects and nested merges be cached
- * @returns {ObjectParsedPropertyEntry<T> | ObjectParsedPropertyEntry<O> | ObjectParsedPropertyEntry<T & O>} new entry
+ * @returns {ObjectParsedPropertyEntry<T> | ObjectParsedPropertyEntry<O> | ObjectParsedPropertyEntry<T & O, MergedValue<T[keyof T] | undefined, O[keyof O] | undefined>>} new entry
  */
 const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 	switch (getValueType(secondEntry.base)) {
@@ -420,13 +440,16 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 			} else {
 				// = first.base + (first.byProperty + second.byProperty)
 				// need to merge first and second byValues
-				/** @type {Map<string, T & O>} */
+				/** @type {ByValues<MergedValue<T[keyof T] | undefined, O[keyof O] | undefined>>} */
 				const newByValues = new Map(firstEntry.byValues);
-				for (const [key, value] of /** @type {ByValues} */ (
+				for (const [
+					key,
+					value
+				] of /** @type {ByValues<O[keyof O] | undefined>} */ (
 					secondEntry.byValues
 				)) {
 					const firstValue = getFromByValues(
-						/** @type {ByValues} */
+						/** @type {ByValues<T[keyof T] | undefined>} */
 						(firstEntry.byValues),
 						key
 					);
@@ -461,7 +484,7 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 			}
 			/** @type {O[keyof O] | T[keyof T] | (T[keyof T] & O[keyof O]) | (T[keyof T] | undefined)[] | (O[keyof O] | undefined)[] | (O[keyof O] | T[keyof T] | undefined)[] | undefined} */
 			let newBase;
-			/** @type {Map<string, (T & O) | O[keyof O] | (O[keyof O] | undefined)[] | ((T & O) | undefined)[] | (T & O & O[keyof O]) | ((T & O) | O[keyof O] | undefined)[] | undefined>} */
+			/** @type {ByValues<MergedValue<T[keyof T] | undefined, O[keyof O] | undefined>>} */
 			const intermediateByValues = new Map(firstEntry.byValues);
 			for (const [key, value] of intermediateByValues) {
 				intermediateByValues.set(
@@ -470,12 +493,14 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 				);
 			}
 			if (
-				[.../** @type {ByValues} */ (firstEntry.byValues).values()].every(
-					(value) => {
-						const type = getValueType(value);
-						return type === VALUE_TYPE_ATOM || type === VALUE_TYPE_DELETE;
-					}
-				)
+				[
+					.../** @type {ByValues<T[keyof T] | undefined>} */ (
+						firstEntry.byValues
+					).values()
+				].every((value) => {
+					const type = getValueType(value);
+					return type === VALUE_TYPE_ATOM || type === VALUE_TYPE_DELETE;
+				})
 			) {
 				// = (first.base + second.base) + ((first.byProperty + second.base) + second.byProperty)
 				newBase = mergeSingleValue(
@@ -502,9 +527,12 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 					`${firstEntry.byProperty} and ${secondEntry.byProperty} for a single property is not supported`
 				);
 			}
-			/** @type {Map<string, (T & O) | O[keyof O] | (O[keyof O] | undefined)[] | (T & O & O[keyof O]) | ((T & O) | undefined)[] | ((T & O) | O[keyof O] | undefined)[] | undefined>} */
+			/** @type {ByValues<MergedValue<T[keyof T] | undefined, O[keyof O] | undefined>>} */
 			const newByValues = new Map(intermediateByValues);
-			for (const [key, value] of /** @type {ByValues} */ (
+			for (const [
+				key,
+				value
+			] of /** @type {ByValues<O[keyof O] | undefined>} */ (
 				secondEntry.byValues
 			)) {
 				const firstValue = getFromByValues(intermediateByValues, key);
@@ -525,7 +553,7 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 /**
  * Gets from by values.
  * @template V
- * @param {ByValues} byValues all values
+ * @param {ByValues<V>} byValues all values
  * @param {string} key value of the selector
  * @returns {V | undefined} value
  */
@@ -543,7 +571,7 @@ const getFromByValues = (byValues, key) => {
  * @param {A | A[]} a value
  * @param {B | B[]} b value
  * @param {boolean} internalCaching should parsing of objects and nested merges be cached
- * @returns {A & B | (A | B)[] | A | A[] | B | B[]} value
+ * @returns {MergedValue<A, B>} value
  */
 const mergeSingleValue = (a, b, internalCaching) => {
 	const bType = getValueType(b);
@@ -635,7 +663,7 @@ const removeOperations = (obj, keysToKeepOriginalValue = []) => {
 				newObj[key] =
 					/** @type {T[keyof T]} */
 					(
-						/** @type {EXPECTED_ANY[]} */
+						/** @type {T[keyof T] extends readonly (infer E)[] ? E[] : never} */
 						(value).filter((i) => i !== "...")
 					);
 				break;

package/lib/util/comparators.js

@@ -8,17 +8,17 @@
 const { getFullModuleName } = require("../ids/IdHelpers");
 const { compareRuntime } = require("./runtime");
 
-/** @import Chunk, { ChunkName, ChunkId } from "../Chunk" */
-/** @import ChunkGraph, { ModuleId } from "../ChunkGraph" */
-/** @import ChunkGroup from "../ChunkGroup" */
+/** @import Chunk, { ChunkName, ChunkId } from "../graph/Chunk" */
+/** @import ChunkGraph, { ModuleId } from "../graph/ChunkGraph" */
+/** @import ChunkGroup from "../graph/ChunkGroup" */
 /** @import Compiler from "../Compiler" */
-/** @import Dependency, { DependencyLocation } from "../Dependency" */
-/** @import HarmonyImportSideEffectDependency from "../dependencies/HarmonyImportSideEffectDependency" */
-/** @import HarmonyImportSpecifierDependency from "../dependencies/HarmonyImportSpecifierDependency" */
-/** @import Module from "../Module" */
-/** @import ModuleGraph from "../ModuleGraph" */
+/** @import Dependency, { DependencyLocation } from "../graph/Dependency" */
+/** @import ESMImportSideEffectDependency from "../dependencies/esm/ESMImportSideEffectDependency" */
+/** @import ESMImportSpecifierDependency from "../dependencies/esm/ESMImportSpecifierDependency" */
+/** @import Module from "../module/Module" */
+/** @import ModuleGraph from "../graph/ModuleGraph" */
 /** @import WebpackErrorType from "../errors/WebpackError" */
-/** @import ModuleDependency from "../dependencies/ModuleDependency" */
+/** @import ModuleDependency from "../dependencies/core/ModuleDependency" */
 
 /**
  * Defines the dependency source order type used by this module.
@@ -93,7 +93,9 @@ const compareIds = (a, b) => {
  */
 const compareIterables = (elementComparator) => {
 	const cacheEntry = compareIteratorsCache.get(elementComparator);
-	if (cacheEntry !== undefined) return cacheEntry;
+	if (cacheEntry !== undefined) {
+		return /** @type {Comparator<Iterable<T>>} */ (cacheEntry);
+	}
 	/**
 	 * Returns compare result.
 	 * @param {Iterable<T>} a first value
@@ -419,7 +421,7 @@ class TwoKeyWeakMap {
 	}
 }
 
-/** @type {TwoKeyWeakMap<Comparator<EXPECTED_ANY>, Comparator<EXPECTED_ANY>, Comparator<EXPECTED_ANY>>}} */
+/** @type {TwoKeyWeakMap<Comparator<never>, Comparator<never>, Comparator<never>>} */
 const concatComparatorsCache = new TwoKeyWeakMap();
 
 /**
@@ -460,7 +462,7 @@ const concatComparators = (c1, c2, ...cRest) => {
  * @typedef {(input: A) => B | undefined | null} Selector
  */
 
-/** @type {TwoKeyWeakMap<Selector<EXPECTED_ANY, EXPECTED_ANY>, Comparator<EXPECTED_ANY>, Comparator<EXPECTED_ANY>>}} */
+/** @type {TwoKeyWeakMap<(input: never) => void, Comparator<never>, Comparator<never>>} */
 const compareSelectCache = new TwoKeyWeakMap();
 
 /**
@@ -473,7 +475,9 @@ const compareSelectCache = new TwoKeyWeakMap();
  */
 const compareSelect = (getter, comparator) => {
 	const cacheEntry = compareSelectCache.get(getter, comparator);
-	if (cacheEntry !== undefined) return cacheEntry;
+	if (cacheEntry !== undefined) {
+		return /** @type {Comparator<T>} */ (cacheEntry);
+	}
 	/**
 	 * Returns compare result.
 	 * @param {T} a first value
@@ -530,7 +534,7 @@ const compareErrors = concatComparators(
 	)
 );
 
-/** @type {WeakMap<Comparator<EXPECTED_ANY>, Comparator<Iterable<EXPECTED_ANY>>>} */
+/** @type {WeakMap<Comparator<never>, Comparator<Iterable<never>>>} */
 const compareIteratorsCache = new WeakMap();
 
 // TODO this is no longer needed when minimum node.js version is >= 12
@@ -579,7 +583,7 @@ const compareChunksNatural = (chunkGraph) => {
 };
 
 /**
- * For HarmonyImportSideEffectDependency and HarmonyImportSpecifierDependency, we should prioritize import order to match the behavior of running modules directly in a JS engine without a bundler.
+ * For ESMImportSideEffectDependency and ESMImportSpecifierDependency, we should prioritize import order to match the behavior of running modules directly in a JS engine without a bundler.
  * For other types like ConstDependency, we can instead prioritize usage order.
  * https://github.com/webpack/webpack/pull/19686
  * @param {Dependency[]} dependencies dependencies