webpack 5.103.0 → 5.104.1

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