webpack 5.102.1 → 5.104.0

package/lib/util/comparators.js

@@ -19,6 +19,7 @@ const { compareRuntime } = require("./runtime");
 /** @typedef {import("../dependencies/HarmonyImportSpecifierDependency")} HarmonyImportSpecifierDependency */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../dependencies/ModuleDependency")} ModuleDependency */
 
 /**
  * @typedef {object} DependencySourceOrder
@@ -56,7 +57,7 @@ const createCachedParameterizedComparator = (fn) => {
 		/**
 		 * @param {T} a first item
 		 * @param {T} b second item
-		 * @returns {-1|0|1} compare result
+		 * @returns {-1 | 0 | 1} compare result
 		 */
 		const result = fn.bind(null, arg);
 		map.set(/** @type {EXPECTED_OBJECT} */ (arg), result);
@@ -89,7 +90,7 @@ const compareIterables = (elementComparator) => {
 	/**
 	 * @param {Iterable<T>} a first value
 	 * @param {Iterable<T>} b second value
-	 * @returns {-1|0|1} compare result
+	 * @returns {-1 | 0 | 1} compare result
 	 */
 	const result = (a, b) => {
 		const aI = a[Symbol.iterator]();
@@ -114,7 +115,7 @@ const compareIterables = (elementComparator) => {
  * Compare two locations
  * @param {DependencyLocation} a A location node
  * @param {DependencyLocation} b A location node
- * @returns {-1|0|1} sorting comparator value
+ * @returns {-1 | 0 | 1} sorting comparator value
  */
 const compareLocations = (a, b) => {
 	const isObjectA = typeof a === "object" && a !== null;
@@ -177,7 +178,7 @@ const compareLocations = (a, b) => {
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @param {Module} a module
  * @param {Module} b module
- * @returns {-1|0|1} compare result
+ * @returns {-1 | 0 | 1} compare result
  */
 const compareModulesById = (chunkGraph, a, b) =>
 	compareIds(
@@ -188,7 +189,7 @@ const compareModulesById = (chunkGraph, a, b) =>
 /**
  * @param {number} a number
  * @param {number} b number
- * @returns {-1|0|1} compare result
+ * @returns {-1 | 0 | 1} compare result
  */
 const compareNumbers = (a, b) => {
 	if (typeof a !== typeof b) {
@@ -202,7 +203,7 @@ const compareNumbers = (a, b) => {
 /**
  * @param {string} a string
  * @param {string} b string
- * @returns {-1|0|1} compare result
+ * @returns {-1 | 0 | 1} compare result
  */
 const compareStringsNumeric = (a, b) => {
 	const aLength = a.length;
@@ -274,7 +275,7 @@ const compareStringsNumeric = (a, b) => {
  * @param {ModuleGraph} moduleGraph the module graph
  * @param {Module} a module
  * @param {Module} b module
- * @returns {-1|0|1} compare result
+ * @returns {-1 | 0 | 1} compare result
  */
 const compareModulesByPostOrderIndexOrIdentifier = (moduleGraph, a, b) => {
 	const cmp = compareNumbers(
@@ -289,7 +290,7 @@ const compareModulesByPostOrderIndexOrIdentifier = (moduleGraph, a, b) => {
  * @param {ModuleGraph} moduleGraph the module graph
  * @param {Module} a module
  * @param {Module} b module
- * @returns {-1|0|1} compare result
+ * @returns {-1 | 0 | 1} compare result
  */
 const compareModulesByPreOrderIndexOrIdentifier = (moduleGraph, a, b) => {
 	const cmp = compareNumbers(
@@ -304,7 +305,7 @@ const compareModulesByPreOrderIndexOrIdentifier = (moduleGraph, a, b) => {
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @param {Module} a module
  * @param {Module} b module
- * @returns {-1|0|1} compare result
+ * @returns {-1 | 0 | 1} compare result
  */
 const compareModulesByIdOrIdentifier = (chunkGraph, a, b) => {
 	const cmp = compareIds(
@@ -326,7 +327,7 @@ const compareChunks = (chunkGraph, a, b) => chunkGraph.compareChunks(a, b);
 /**
  * @param {string} a first string
  * @param {string} b second string
- * @returns {-1|0|1} compare result
+ * @returns {-1 | 0 | 1} compare result
  */
 const compareStrings = (a, b) => {
 	if (a < b) return -1;
@@ -407,7 +408,7 @@ const concatComparators = (c1, c2, ...cRest) => {
 	/**
 	 * @param {T} a first value
 	 * @param {T} b second value
-	 * @returns {-1|0|1} compare result
+	 * @returns {-1 | 0 | 1} compare result
 	 */
 	const result = (a, b) => {
 		const res = c1(a, b);
@@ -439,7 +440,7 @@ const compareSelect = (getter, comparator) => {
 	/**
 	 * @param {T} a first value
 	 * @param {T} b second value
-	 * @returns {-1|0|1} compare result
+	 * @returns {-1 | 0 | 1} compare result
 	 */
 	const result = (a, b) => {
 		const aValue = getter(a);
@@ -510,47 +511,42 @@ const compareChunksNatural = (chunkGraph) => {
  * https://github.com/webpack/webpack/pull/19686
  * @param {Dependency[]} dependencies dependencies
  * @param {WeakMap<Dependency, DependencySourceOrder>} dependencySourceOrderMap dependency source order map
+ * @param {((dep: Dependency, index: number) => void)=} onDependencyReSort optional callback to set index for each dependency
  * @returns {void}
  */
-const sortWithSourceOrder = (dependencies, dependencySourceOrderMap) => {
-	/**
-	 * @param {Dependency} dep dependency
-	 * @returns {number} source order
-	 */
-	const getSourceOrder = (dep) => {
-		if (dependencySourceOrderMap.has(dep)) {
-			const { main } = /** @type {DependencySourceOrder} */ (
-				dependencySourceOrderMap.get(dep)
-			);
-			return main;
-		}
-		return /** @type { HarmonyImportSideEffectDependency | HarmonyImportSpecifierDependency} */ (
-			dep
-		).sourceOrder;
-	};
-
-	/**
-	 * If the sourceOrder is a number, it means the dependency needs to be sorted.
-	 * @param {number | undefined} sourceOrder sourceOrder
-	 * @returns {boolean} needReSort
-	 */
-	const needReSort = (sourceOrder) => {
-		if (typeof sourceOrder === "number") {
-			return true;
-		}
-		return false;
-	};
-
-	// Extract dependencies with sourceOrder and sort them
+const sortWithSourceOrder = (
+	dependencies,
+	dependencySourceOrderMap,
+	onDependencyReSort
+) => {
+	/** @type {{dep: Dependency, main: number, sub: number}[]} */
 	const withSourceOrder = [];
+	/** @type {number[]} */
+	const positions = [];
 
-	// First pass: collect dependencies with sourceOrder
 	for (let i = 0; i < dependencies.length; i++) {
 		const dep = dependencies[i];
-		const sourceOrder = getSourceOrder(dep);
-
-		if (needReSort(sourceOrder)) {
-			withSourceOrder.push({ dep, sourceOrder, originalIndex: i });
+		const cached = dependencySourceOrderMap.get(dep);
+
+		if (cached) {
+			positions.push(i);
+			withSourceOrder.push({
+				dep,
+				main: cached.main,
+				sub: cached.sub
+			});
+		} else {
+			const sourceOrder = /** @type {number | undefined} */ (
+				/** @type {ModuleDependency} */ (dep).sourceOrder
+			);
+			if (typeof sourceOrder === "number") {
+				positions.push(i);
+				withSourceOrder.push({
+					dep,
+					main: sourceOrder,
+					sub: 0
+				});
+			}
 		}
 	}
 
@@ -558,37 +554,19 @@ const sortWithSourceOrder = (dependencies, dependencySourceOrderMap) => {
 		return;
 	}
 
-	// Sort dependencies with sourceOrder
 	withSourceOrder.sort((a, b) => {
-		// Handle both dependencies in map case
-		if (
-			dependencySourceOrderMap.has(a.dep) &&
-			dependencySourceOrderMap.has(b.dep)
-		) {
-			const { main: mainA, sub: subA } = /** @type {DependencySourceOrder} */ (
-				dependencySourceOrderMap.get(a.dep)
-			);
-			const { main: mainB, sub: subB } = /** @type {DependencySourceOrder} */ (
-				dependencySourceOrderMap.get(b.dep)
-			);
-			if (mainA === mainB) {
-				return compareNumbers(subA, subB);
-			}
-			return compareNumbers(mainA, mainB);
+		if (a.main !== b.main) {
+			return compareNumbers(a.main, b.main);
 		}
-
-		return compareNumbers(a.sourceOrder, b.sourceOrder);
+		return compareNumbers(a.sub, b.sub);
 	});
 
-	// Second pass: build result array
-	let sortedIndex = 0;
-	for (let i = 0; i < dependencies.length; i++) {
-		const dep = dependencies[i];
-		const sourceOrder = getSourceOrder(dep);
-
-		if (needReSort(sourceOrder)) {
-			dependencies[i] = withSourceOrder[sortedIndex].dep;
-			sortedIndex++;
+	// Second pass: place sorted deps back to original positions
+	for (let i = 0; i < positions.length; i++) {
+		const depIndex = positions[i];
+		dependencies[depIndex] = withSourceOrder[i].dep;
+		if (onDependencyReSort) {
+			onDependencyReSort(dependencies[depIndex], depIndex);
 		}
 	}
 };
@@ -600,7 +578,7 @@ module.exports.compareChunks =
 /**
  * @param {Chunk} a chunk
  * @param {Chunk} b chunk
- * @returns {-1|0|1} compare result
+ * @returns {-1 | 0 | 1} compare result
  */
 module.exports.compareChunksById = (a, b) =>
 	compareIds(/** @type {ChunkId} */ (a.id), /** @type {ChunkId} */ (b.id));
@@ -621,7 +599,7 @@ module.exports.compareModulesByIdOrIdentifier =
 /**
  * @param {Module} a module
  * @param {Module} b module
- * @returns {-1|0|1} compare result
+ * @returns {-1 | 0 | 1} compare result
  */
 module.exports.compareModulesByIdentifier = (a, b) =>
 	compareIds(a.identifier(), b.identifier());

package/lib/util/compileBooleanMatcher.js

@@ -11,6 +11,79 @@
  */
 const quoteMeta = (str) => str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
 
+/**
+ * @param {string} char character to escape for use in character class
+ * @returns {string} escaped character
+ */
+const quoteMetaInCharClass = (char) => {
+	// In character class, only these need escaping: ] \ ^ -
+	if (char === "]" || char === "\\" || char === "^" || char === "-") {
+		return `\\${char}`;
+	}
+	return char;
+};
+
+/**
+ * Converts an array of single characters into an optimized character class string
+ * using ranges where possible. E.g., ["1","2","3","4","a"] => "1-4a"
+ * @param {string[]} chars array of single characters (should be sorted)
+ * @returns {string} optimized character class content (without the brackets)
+ */
+const charsToCharClassContent = (chars) => {
+	if (chars.length === 0) return "";
+	if (chars.length === 1) return quoteMetaInCharClass(chars[0]);
+
+	// Sort by char code
+	const sorted = [...chars].sort((a, b) => a.charCodeAt(0) - b.charCodeAt(0));
+
+	/** @type {string[]} */
+	const parts = [];
+	let rangeStart = sorted[0];
+	let rangeEnd = sorted[0];
+
+	for (let i = 1; i < sorted.length; i++) {
+		const char = sorted[i];
+		const prevCode = rangeEnd.charCodeAt(0);
+		const currCode = char.charCodeAt(0);
+
+		if (currCode === prevCode + 1) {
+			// Extend the range
+			rangeEnd = char;
+		} else {
+			// Flush the current range
+			parts.push(formatRange(rangeStart, rangeEnd));
+			rangeStart = char;
+			rangeEnd = char;
+		}
+	}
+	// Flush the last range
+	parts.push(formatRange(rangeStart, rangeEnd));
+
+	return parts.join("");
+};
+
+/**
+ * Formats a range of characters for use in a character class
+ * @param {string} start start character
+ * @param {string} end end character
+ * @returns {string} formatted range
+ */
+const formatRange = (start, end) => {
+	const startCode = start.charCodeAt(0);
+	const endCode = end.charCodeAt(0);
+	const length = endCode - startCode + 1;
+
+	if (length === 1) {
+		return quoteMetaInCharClass(start);
+	}
+	if (length === 2) {
+		// For 2 chars, just list them (e.g., "ab" instead of "a-b")
+		return quoteMetaInCharClass(start) + quoteMetaInCharClass(end);
+	}
+	// For 3+ chars, use range notation
+	return `${quoteMetaInCharClass(start)}-${quoteMetaInCharClass(end)}`;
+};
+
 /**
  * @param {string} str string
  * @returns {string} string
@@ -148,19 +221,20 @@ const itemsToRegexp = (itemsArr) => {
 	}
 	// special case for only single char items
 	if (countOfSingleCharItems === itemsArr.length) {
-		return `[${quoteMeta(itemsArr.sort().join(""))}]`;
+		return `[${charsToCharClassContent(itemsArr)}]`;
 	}
 	/** @type {Set<string>} */
 	const items = new Set(itemsArr.sort());
 	if (countOfSingleCharItems > 2) {
-		let singleCharItems = "";
+		/** @type {string[]} */
+		const singleCharItems = [];
 		for (const item of items) {
 			if (item.length === 1) {
-				singleCharItems += item;
+				singleCharItems.push(item);
 				items.delete(item);
 			}
 		}
-		finishedItems.push(`[${quoteMeta(singleCharItems)}]`);
+		finishedItems.push(`[${charsToCharClassContent(singleCharItems)}]`);
 	}
 
 	// special case for 2 items with common prefix/suffix
@@ -227,8 +301,6 @@ const itemsToRegexp = (itemsArr) => {
 		);
 	}
 
-	// TODO further optimize regexp, i. e.
-	// use ranges: (1|2|3|4|a) => [1-4a]
 	/** @type {string[]} */
 	const conditional = [...finishedItems, ...Array.from(items, quoteMeta)];
 	if (conditional.length === 1) return conditional[0];

package/lib/util/createHash.js

@@ -5,212 +5,21 @@
 
 "use strict";
 
-const Hash = require("./Hash");
-
-/** @typedef {import("../../declarations/WebpackOptions").HashDigest} Encoding */
+/** @typedef {import("./Hash")} Hash */
 /** @typedef {import("../../declarations/WebpackOptions").HashFunction} HashFunction */
 
-const BULK_SIZE = 3;
-
-// We are using an object instead of a Map as this will stay static during the runtime
-// so access to it can be optimized by v8
-/** @type {{[key: string]: Map<string, string>}} */
-const digestCaches = {};
-
-/** @typedef {() => Hash} HashFactory */
-
-class BulkUpdateDecorator extends Hash {
-	/**
-	 * @param {Hash | HashFactory} hashOrFactory function to create a hash
-	 * @param {string=} hashKey key for caching
-	 */
-	constructor(hashOrFactory, hashKey) {
-		super();
-		this.hashKey = hashKey;
-		if (typeof hashOrFactory === "function") {
-			this.hashFactory = hashOrFactory;
-			this.hash = undefined;
-		} else {
-			this.hashFactory = undefined;
-			this.hash = hashOrFactory;
-		}
-		this.buffer = "";
-	}
-
-	/**
-	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
-	 * @overload
-	 * @param {string | Buffer} data data
-	 * @returns {Hash} updated hash
-	 */
-	/**
-	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
-	 * @overload
-	 * @param {string} data data
-	 * @param {Encoding} inputEncoding data encoding
-	 * @returns {Hash} updated hash
-	 */
-	/**
-	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
-	 * @param {string | Buffer} data data
-	 * @param {Encoding=} inputEncoding data encoding
-	 * @returns {Hash} updated hash
-	 */
-	update(data, inputEncoding) {
-		if (
-			inputEncoding !== undefined ||
-			typeof data !== "string" ||
-			data.length > BULK_SIZE
-		) {
-			if (this.hash === undefined) {
-				this.hash = /** @type {HashFactory} */ (this.hashFactory)();
-			}
-			if (this.buffer.length > 0) {
-				this.hash.update(this.buffer);
-				this.buffer = "";
-			}
-			if (typeof data === "string" && inputEncoding) {
-				this.hash.update(data, inputEncoding);
-			} else {
-				this.hash.update(data);
-			}
-		} else {
-			this.buffer += data;
-			if (this.buffer.length > BULK_SIZE) {
-				if (this.hash === undefined) {
-					this.hash = /** @type {HashFactory} */ (this.hashFactory)();
-				}
-				this.hash.update(this.buffer);
-				this.buffer = "";
-			}
-		}
-		return this;
-	}
-
-	/**
-	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
-	 * @overload
-	 * @returns {Buffer} digest
-	 */
-	/**
-	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
-	 * @overload
-	 * @param {Encoding} encoding encoding of the return value
-	 * @returns {string} digest
-	 */
-	/**
-	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
-	 * @param {Encoding=} encoding encoding of the return value
-	 * @returns {string | Buffer} digest
-	 */
-	digest(encoding) {
-		let digestCache;
-		const buffer = this.buffer;
-		if (this.hash === undefined) {
-			// short data for hash, we can use caching
-			const cacheKey = `${this.hashKey}-${encoding}`;
-			digestCache = digestCaches[cacheKey];
-			if (digestCache === undefined) {
-				digestCache = digestCaches[cacheKey] = new Map();
-			}
-			const cacheEntry = digestCache.get(buffer);
-			if (cacheEntry !== undefined) return cacheEntry;
-			this.hash = /** @type {HashFactory} */ (this.hashFactory)();
-		}
-		if (buffer.length > 0) {
-			this.hash.update(buffer);
-		}
-		if (!encoding) {
-			const result = this.hash.digest();
-			if (digestCache !== undefined) {
-				digestCache.set(buffer, result);
-			}
-			return result;
-		}
-		const digestResult = this.hash.digest(encoding);
-		// Compatibility with the old hash library
-		const result =
-			typeof digestResult === "string"
-				? digestResult
-				: /** @type {NodeJS.TypedArray} */ (digestResult).toString();
-		if (digestCache !== undefined) {
-			digestCache.set(buffer, result);
-		}
-		return result;
-	}
-}
-
-/* istanbul ignore next */
-class DebugHash extends Hash {
-	constructor() {
-		super();
-		this.string = "";
-	}
-
-	/**
-	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
-	 * @overload
-	 * @param {string | Buffer} data data
-	 * @returns {Hash} updated hash
-	 */
-	/**
-	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
-	 * @overload
-	 * @param {string} data data
-	 * @param {Encoding} inputEncoding data encoding
-	 * @returns {Hash} updated hash
-	 */
-	/**
-	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
-	 * @param {string | Buffer} data data
-	 * @param {Encoding=} inputEncoding data encoding
-	 * @returns {Hash} updated hash
-	 */
-	update(data, inputEncoding) {
-		if (typeof data !== "string") data = data.toString("utf8");
-		const prefix = Buffer.from("@webpack-debug-digest@").toString("hex");
-		if (data.startsWith(prefix)) {
-			data = Buffer.from(data.slice(prefix.length), "hex").toString();
-		}
-		this.string += `[${data}](${
-			/** @type {string} */
-			(
-				// eslint-disable-next-line unicorn/error-message
-				new Error().stack
-			).split("\n", 3)[2]
-		})\n`;
-		return this;
-	}
-
-	/**
-	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
-	 * @overload
-	 * @returns {Buffer} digest
-	 */
-	/**
-	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
-	 * @overload
-	 * @param {Encoding} encoding encoding of the return value
-	 * @returns {string} digest
-	 */
-	/**
-	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
-	 * @param {Encoding=} encoding encoding of the return value
-	 * @returns {string | Buffer} digest
-	 */
-	digest(encoding) {
-		return Buffer.from(`@webpack-debug-digest@${this.string}`).toString("hex");
-	}
-}
-
 /** @type {typeof import("crypto") | undefined} */
 let crypto;
 /** @type {typeof import("./hash/xxhash64") | undefined} */
 let createXXHash64;
 /** @type {typeof import("./hash/md4") | undefined} */
 let createMd4;
+/** @type {typeof import("./hash/DebugHash") | undefined} */
+let DebugHash;
 /** @type {typeof import("./hash/BatchedHash") | undefined} */
 let BatchedHash;
+/** @type {typeof import("./hash/BulkUpdateHash") | undefined} */
+let BulkUpdateHash;
 
 /**
  * Creates a hash by name or function
@@ -219,12 +28,18 @@ let BatchedHash;
  */
 module.exports = (algorithm) => {
 	if (typeof algorithm === "function") {
+		if (BulkUpdateHash === undefined) {
+			BulkUpdateHash = require("./hash/BulkUpdateHash");
+		}
 		// eslint-disable-next-line new-cap
-		return new BulkUpdateDecorator(() => new algorithm());
+		return new BulkUpdateHash(() => new algorithm());
 	}
 	switch (algorithm) {
 		// TODO add non-cryptographic algorithm here
 		case "debug":
+			if (DebugHash === undefined) {
+				DebugHash = require("./hash/DebugHash");
+			}
 			return new DebugHash();
 		case "xxhash64":
 			if (createXXHash64 === undefined) {
@@ -248,7 +63,10 @@ module.exports = (algorithm) => {
 			)(createMd4());
 		case "native-md4":
 			if (crypto === undefined) crypto = require("crypto");
-			return new BulkUpdateDecorator(
+			if (BulkUpdateHash === undefined) {
+				BulkUpdateHash = require("./hash/BulkUpdateHash");
+			}
+			return new BulkUpdateHash(
 				() =>
 					/** @type {Hash} */ (
 						/** @type {typeof import("crypto")} */
@@ -258,7 +76,10 @@ module.exports = (algorithm) => {
 			);
 		default:
 			if (crypto === undefined) crypto = require("crypto");
-			return new BulkUpdateDecorator(
+			if (BulkUpdateHash === undefined) {
+				BulkUpdateHash = require("./hash/BulkUpdateHash");
+			}
+			return new BulkUpdateHash(
 				() =>
 					/** @type {Hash} */ (
 						/** @type {typeof import("crypto")} */

package/lib/util/deprecation.js

@@ -194,7 +194,7 @@ module.exports.arrayToSetDeprecation = (set, name) => {
 /**
  * @template T
  * @param {string} name name
- * @returns {{ new <T = any>(values?: ReadonlyArray<T> | null): SetDeprecatedArray<T> }} SetDeprecatedArray
+ * @returns {{ new <T = EXPECTED_ANY>(values?: ReadonlyArray<T> | null): SetDeprecatedArray<T> }} SetDeprecatedArray
  */
 module.exports.createArrayToSetDeprecationSet = (name) => {
 	let initialized = false;

package/lib/util/deterministicGrouping.js

@@ -137,12 +137,15 @@ const isTooSmall = (size, minSize) => {
 	return false;
 };
 
+/** @typedef {Set<string>} Types */
+
 /**
  * @param {Sizes} size size
  * @param {Sizes} minSize minimum size
- * @returns {Set<string>} set of types that are too small
+ * @returns {Types} set of types that are too small
  */
 const getTooSmallTypes = (size, minSize) => {
+	/** @typedef {Types} */
 	const types = new Set();
 	for (const key of Object.keys(size)) {
 		const s = size[key];
@@ -156,7 +159,7 @@ const getTooSmallTypes = (size, minSize) => {
 /**
  * @template {object} T
  * @param {T} size size
- * @param {Set<string>} types types
+ * @param {Types} types types
  * @returns {number} number of matching size types
  */
 const getNumberOfMatchingSizeTypes = (size, types) => {
@@ -169,7 +172,7 @@ const getNumberOfMatchingSizeTypes = (size, types) => {
 
 /**
  * @param {Sizes} size size
- * @param {Set<string>} types types
+ * @param {Types} types types
  * @returns {number} selective size sum
  */
 const selectiveSizeSum = (size, types) => {