webpack 5.101.3 → 5.102.1

package/lib/util/cleverMerge.js

@@ -92,7 +92,7 @@ const cachedSetProperty = (obj, property, value) => {
  * @template T
  * @typedef {object} ObjectParsedPropertyEntry
  * @property {T[keyof T] | undefined} base base value
- * @property {string | undefined} byProperty the name of the selector property
+ * @property {`by${string}` | undefined} byProperty the name of the selector property
  * @property {ByValues | undefined} byValues value depending on selector property, merged with base
  */
 
@@ -105,7 +105,7 @@ const cachedSetProperty = (obj, property, value) => {
 
 /**
  * @template {object} T
- * @typedef {{ byProperty: string, fn: DynamicFunction }} ParsedObjectDynamic
+ * @typedef {{ byProperty: `by${string}`, fn: DynamicFunction }} ParsedObjectDynamic
  */
 
 /**
@@ -169,7 +169,7 @@ const parseObject = (obj) => {
 					for (const key of Object.keys(obj)) {
 						const entry = getInfo(/** @type {keyof T} */ (key));
 						if (entry.byProperty === undefined) {
-							entry.byProperty = byProperty;
+							entry.byProperty = /** @type {`by${string}`} */ (byProperty);
 							entry.byValues = new Map();
 						} else if (entry.byProperty !== byProperty) {
 							throw new Error(
@@ -196,7 +196,7 @@ const parseObject = (obj) => {
 			} else if (typeof byObj === "function") {
 				if (dynamicInfo === undefined) {
 					dynamicInfo = {
-						byProperty: key,
+						byProperty: /** @type {`by${string}`} */ (key),
 						fn: byObj
 					};
 				} else {
@@ -222,17 +222,16 @@ const parseObject = (obj) => {
 /**
  * @template {object} T
  * @param {ParsedObjectStatic<T>} info static properties (key is property name)
- * @param {{ byProperty: string, fn: DynamicFunction } | undefined} dynamicInfo dynamic part
+ * @param {{ byProperty: `by${string}`, fn: DynamicFunction } | undefined} dynamicInfo dynamic part
  * @returns {T} the object
  */
 const serializeObject = (info, dynamicInfo) => {
-	const obj = /** @type {T} */ ({});
+	const obj = /** @type {EXPECTED_ANY} */ ({});
 	// Setup byProperty structure
 	for (const entry of info.values()) {
 		if (entry.byProperty !== undefined) {
-			const byProperty = /** @type {keyof T} */ (entry.byProperty);
-			const byObj = (obj[byProperty] =
-				obj[byProperty] || /** @type {TODO} */ ({}));
+			const byProperty = entry.byProperty;
+			const byObj = (obj[byProperty] = obj[byProperty] || {});
 			for (const byValue of /** @type {ByValues} */ (entry.byValues).keys()) {
 				byObj[byValue] = byObj[byValue] || {};
 			}
@@ -240,13 +239,12 @@ const serializeObject = (info, dynamicInfo) => {
 	}
 	for (const [key, entry] of info) {
 		if (entry.base !== undefined) {
-			obj[/** @type {keyof T} */ (key)] = entry.base;
+			obj[key] = entry.base;
 		}
 		// Fill byProperty structure
 		if (entry.byProperty !== undefined) {
-			const byProperty = /** @type {keyof T} */ (entry.byProperty);
-			const byObj = (obj[byProperty] =
-				obj[byProperty] || /** @type {TODO} */ ({}));
+			const byProperty = entry.byProperty;
+			const byObj = (obj[byProperty] = obj[byProperty] || {});
 			for (const byValue of Object.keys(byObj)) {
 				const value = getFromByValues(
 					/** @type {ByValues} */
@@ -258,8 +256,7 @@ const serializeObject = (info, dynamicInfo) => {
 		}
 	}
 	if (dynamicInfo !== undefined) {
-		/** @type {TODO} */
-		(obj)[dynamicInfo.byProperty] = dynamicInfo.fn;
+		obj[dynamicInfo.byProperty] = dynamicInfo.fn;
 	}
 	return obj;
 };
@@ -384,7 +381,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<TODO>} new entry
+ * @returns {ObjectParsedPropertyEntry<T> | ObjectParsedPropertyEntry<O> | ObjectParsedPropertyEntry<T & O>} new entry
  */
 const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 	switch (getValueType(secondEntry.base)) {
@@ -479,7 +476,7 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 			if (!secondEntry.byProperty) {
 				// = first.base + (first.byProperty + second.base)
 				return {
-					base: newBase,
+					base: /** @type {T[keyof T] & O[keyof O]} */ (newBase),
 					byProperty: firstEntry.byProperty,
 					byValues: intermediateByValues
 				};
@@ -499,7 +496,7 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 				);
 			}
 			return {
-				base: newBase,
+				base: /** @type {T[keyof T] & O[keyof O]} */ (newBase),
 				byProperty: firstEntry.byProperty,
 				byValues: newByValues
 			};

package/lib/util/comparators.js

@@ -8,6 +8,7 @@
 const { compareRuntime } = require("./runtime");
 
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Chunk").ChunkName} ChunkName */
 /** @typedef {import("../Chunk").ChunkId} ChunkId */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../ChunkGraph").ModuleId} ModuleId */
@@ -490,10 +491,7 @@ const compareChunksNatural = (chunkGraph) => {
 	const cmpFn = module.exports.compareModulesById(chunkGraph);
 	const cmpIterableFn = compareIterables(cmpFn);
 	return concatComparators(
-		compareSelect(
-			(chunk) => /** @type {string|number} */ (chunk.name),
-			compareIds
-		),
+		compareSelect((chunk) => /** @type {ChunkName} */ (chunk.name), compareIds),
 		compareSelect((chunk) => chunk.runtime, compareRuntime),
 		compareSelect(
 			/**

package/lib/util/compileBooleanMatcher.js

@@ -56,28 +56,30 @@ const compileBooleanMatcherFromLists = (positiveItems, negativeItems) => {
 	return (value) => `!/^${negativeRegexp}$/.test(${value})`;
 };
 
+/** @typedef {string[][]} ListOfCommonItems */
+
 /**
  * @param {Set<string>} itemsSet items set
  * @param {(str: string) => string | false} getKey get key function
- * @param {(str: Array<string>) => boolean} condition condition
- * @returns {Array<Array<string>>} list of common items
+ * @param {(str: string[]) => boolean} condition condition
+ * @returns {ListOfCommonItems} list of common items
  */
 const popCommonItems = (itemsSet, getKey, condition) => {
-	/** @type {Map<string, Array<string>>} */
+	/** @type {Map<string, string[]>} */
 	const map = new Map();
 	for (const item of itemsSet) {
 		const key = getKey(item);
 		if (key) {
 			let list = map.get(key);
 			if (list === undefined) {
-				/** @type {Array<string>} */
+				/** @type {string[]} */
 				list = [];
 				map.set(key, list);
 			}
 			list.push(item);
 		}
 	}
-	/** @type {Array<Array<string>>} */
+	/** @type {ListOfCommonItems} */
 	const result = [];
 	for (const list of map.values()) {
 		if (condition(list)) {
@@ -91,7 +93,7 @@ const popCommonItems = (itemsSet, getKey, condition) => {
 };
 
 /**
- * @param {Array<string>} items items
+ * @param {string[]} items items
  * @returns {string} common prefix
  */
 const getCommonPrefix = (items) => {
@@ -109,7 +111,7 @@ const getCommonPrefix = (items) => {
 };
 
 /**
- * @param {Array<string>} items items
+ * @param {string[]} items items
  * @returns {string} common suffix
  */
 const getCommonSuffix = (items) => {
@@ -127,14 +129,14 @@ const getCommonSuffix = (items) => {
 };
 
 /**
- * @param {Array<string>} itemsArr array of items
+ * @param {string[]} itemsArr array of items
  * @returns {string} regexp
  */
 const itemsToRegexp = (itemsArr) => {
 	if (itemsArr.length === 1) {
 		return quoteMeta(itemsArr[0]);
 	}
-	/** @type {Array<string>} */
+	/** @type {string[]} */
 	const finishedItems = [];
 
 	// merge single char items: (a|b|c|d|ef) => ([abcd]|ef)

package/lib/util/concatenate.js

@@ -12,7 +12,6 @@ const Template = require("../Template");
 /** @typedef {import("eslint-scope").Variable} Variable */
 /** @typedef {import("estree").Node} Node */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../javascript/JavascriptParser").Program} Program */
 /** @typedef {Set<string>} UsedNames */
 
 const DEFAULT_EXPORT = "__WEBPACK_DEFAULT_EXPORT__";
@@ -72,7 +71,7 @@ const getPathInAst = (ast, node) => {
 		}
 	} else if (ast && typeof ast === "object") {
 		const keys =
-			/** @type {Array<keyof Node>} */
+			/** @type {(keyof Node)[]} */
 			(Object.keys(ast));
 		for (let i = 0; i < keys.length; i++) {
 			// We are making the faster check in `enterNode` using `n.range`

package/lib/util/create-schema-validation.js

@@ -8,8 +8,7 @@
 const memoize = require("./memoize");
 
 /** @typedef {import("schema-utils").Schema} Schema */
-/** @typedef {import("schema-utils/declarations/validate").ValidationErrorConfiguration} ValidationErrorConfiguration */
-/** @typedef {import("./fs").JsonObject} JsonObject */
+/** @typedef {import("schema-utils").ValidationErrorConfiguration} ValidationErrorConfiguration */
 
 const getValidate = memoize(() => require("schema-utils").validate);
 

package/lib/util/createHash.js

@@ -7,9 +7,10 @@
 
 const Hash = require("./Hash");
 
+/** @typedef {import("../../declarations/WebpackOptions").HashDigest} Encoding */
 /** @typedef {import("../../declarations/WebpackOptions").HashFunction} HashFunction */
 
-const BULK_SIZE = 2000;
+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
@@ -38,9 +39,22 @@ class BulkUpdateDecorator extends Hash {
 
 	/**
 	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
-	 * @param {string|Buffer} data data
-	 * @param {string=} inputEncoding data encoding
-	 * @returns {this} updated hash
+	 * @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 (
@@ -55,7 +69,11 @@ class BulkUpdateDecorator extends Hash {
 				this.hash.update(this.buffer);
 				this.buffer = "";
 			}
-			this.hash.update(data, inputEncoding);
+			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) {
@@ -71,8 +89,19 @@ class BulkUpdateDecorator extends Hash {
 
 	/**
 	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
-	 * @param {string=} encoding encoding of the return value
-	 * @returns {string|Buffer} digest
+	 * @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;
@@ -91,9 +120,19 @@ class BulkUpdateDecorator extends Hash {
 		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 : digestResult.toString();
+			typeof digestResult === "string"
+				? digestResult
+				: /** @type {NodeJS.TypedArray} */ (digestResult).toString();
 		if (digestCache !== undefined) {
 			digestCache.set(buffer, result);
 		}
@@ -110,9 +149,22 @@ class DebugHash extends Hash {
 
 	/**
 	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
-	 * @param {string|Buffer} data data
-	 * @param {string=} inputEncoding data encoding
-	 * @returns {this} updated hash
+	 * @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");
@@ -132,8 +184,19 @@ class DebugHash extends Hash {
 
 	/**
 	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
-	 * @param {string=} encoding encoding of the return value
-	 * @returns {string|Buffer} digest
+	 * @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");
@@ -186,14 +249,21 @@ module.exports = (algorithm) => {
 		case "native-md4":
 			if (crypto === undefined) crypto = require("crypto");
 			return new BulkUpdateDecorator(
-				() => /** @type {typeof import("crypto")} */ (crypto).createHash("md4"),
+				() =>
+					/** @type {Hash} */ (
+						/** @type {typeof import("crypto")} */
+						(crypto).createHash("md4")
+					),
 				"md4"
 			);
 		default:
 			if (crypto === undefined) crypto = require("crypto");
 			return new BulkUpdateDecorator(
 				() =>
-					/** @type {typeof import("crypto")} */ (crypto).createHash(algorithm),
+					/** @type {Hash} */ (
+						/** @type {typeof import("crypto")} */
+						(crypto).createHash(algorithm)
+					),
 				algorithm
 			);
 	}

package/lib/util/dataURL.js

@@ -0,0 +1,39 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Natsu @xiaoxiaojx
+*/
+
+"use strict";
+
+// data URL scheme: "data:text/javascript;charset=utf-8;base64,some-string"
+// http://www.ietf.org/rfc/rfc2397.txt
+const URIRegEx = /^data:([^;,]+)?((?:;[^;,]+)*?)(?:;(base64)?)?,(.*)$/i;
+
+/**
+ * @param {string} uri data URI
+ * @returns {Buffer | null} decoded data
+ */
+const decodeDataURI = (uri) => {
+	const match = URIRegEx.exec(uri);
+	if (!match) return null;
+
+	const isBase64 = match[3];
+	const body = match[4];
+
+	if (isBase64) {
+		return Buffer.from(body, "base64");
+	}
+
+	// CSS allows to use `data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg"><rect width="100%" height="100%" style="stroke: rgb(223,224,225); stroke-width: 2px; fill: none; stroke-dasharray: 6px 3px" /></svg>`
+	// so we return original body if we can't `decodeURIComponent`
+	try {
+		return Buffer.from(decodeURIComponent(body), "ascii");
+	} catch (_) {
+		return Buffer.from(body, "ascii");
+	}
+};
+
+module.exports = {
+	URIRegEx,
+	decodeDataURI
+};

package/lib/util/deprecation.js

@@ -75,38 +75,37 @@ const DISABLED_METHODS = [
 
 /**
  * @template T
- * @typedef {Set<T> & {[Symbol.isConcatSpreadable]?: boolean} & { push?: (...items: T[]) => void } & { [P in DISABLED_METHODS_NAMES]?: () => void } & { [P in COPY_METHODS_NAMES]?: () => TODO }} SetWithDeprecatedArrayMethods
+ * @typedef {Set<T> & { [Symbol.isConcatSpreadable]: boolean } & { push: (...items: T[]) => void, length?: number } & { [P in DISABLED_METHODS_NAMES]: () => void } & { [P in COPY_METHODS_NAMES]: P extends keyof Array<T> ? () => Pick<Array<T>, P> : never }} SetWithDeprecatedArrayMethods
  */
 
 /**
  * @template T
- * @param {SetWithDeprecatedArrayMethods<T>} set new set
+ * @param {Set<T>} set new set
  * @param {string} name property name
  * @returns {void}
  */
 module.exports.arrayToSetDeprecation = (set, name) => {
 	for (const method of COPY_METHODS) {
-		if (set[method]) continue;
+		if (/** @type {SetWithDeprecatedArrayMethods<T>} */ (set)[method]) continue;
 		const d = createDeprecation(
 			`${name} was changed from Array to Set (using Array method '${method}' is deprecated)`,
 			"ARRAY_TO_SET"
 		);
-		/**
-		 * @deprecated
-		 * @this {Set<T>}
-		 * @returns {number} count
-		 */
-		// eslint-disable-next-line func-names
-		set[method] = function () {
-			d();
-			// eslint-disable-next-line unicorn/prefer-spread
-			const array = Array.from(this);
-			return Array.prototype[/** @type {keyof COPY_METHODS} */ (method)].apply(
-				array,
-				// eslint-disable-next-line prefer-rest-params
-				arguments
-			);
-		};
+		/** @type {EXPECTED_ANY} */
+		(set)[method] =
+			// eslint-disable-next-line func-names
+			function () {
+				d();
+				// eslint-disable-next-line unicorn/prefer-spread
+				const array = Array.from(this);
+				return Array.prototype[
+					/** @type {keyof COPY_METHODS} */ (method)
+				].apply(
+					array,
+					// eslint-disable-next-line prefer-rest-params
+					arguments
+				);
+			};
 	}
 	const dPush = createDeprecation(
 		`${name} was changed from Array to Set (using Array method 'push' is deprecated)`,
@@ -120,12 +119,8 @@ module.exports.arrayToSetDeprecation = (set, name) => {
 		`${name} was changed from Array to Set (indexing Array is deprecated)`,
 		"ARRAY_TO_SET_INDEXER"
 	);
-	/**
-	 * @deprecated
-	 * @this {Set<T>}
-	 * @returns {number} count
-	 */
-	set.push = function push() {
+	/** @type {SetWithDeprecatedArrayMethods<T>} */
+	(set).push = function push() {
 		dPush();
 		// eslint-disable-next-line prefer-rest-params, unicorn/prefer-spread
 		for (const item of Array.from(arguments)) {
@@ -134,9 +129,10 @@ module.exports.arrayToSetDeprecation = (set, name) => {
 		return this.size;
 	};
 	for (const method of DISABLED_METHODS) {
-		if (set[method]) continue;
+		if (/** @type {SetWithDeprecatedArrayMethods<T>} */ (set)[method]) continue;
 
-		set[method] = () => {
+		/** @type {SetWithDeprecatedArrayMethods<T>} */
+		(set)[method] = () => {
 			throw new Error(
 				`${name} was changed from Array to Set (using Array method '${method}' is not possible)`
 			);
@@ -191,13 +187,14 @@ module.exports.arrayToSetDeprecation = (set, name) => {
 			);
 		}
 	});
-	set[Symbol.isConcatSpreadable] = true;
+	/** @type {SetWithDeprecatedArrayMethods<T>} */
+	(set)[Symbol.isConcatSpreadable] = true;
 };
 
 /**
  * @template T
  * @param {string} name name
- * @returns {{ new <T = any>(values?: readonly T[] | null): SetDeprecatedArray<T> }} SetDeprecatedArray
+ * @returns {{ new <T = any>(values?: ReadonlyArray<T> | null): SetDeprecatedArray<T> }} SetDeprecatedArray
  */
 module.exports.createArrayToSetDeprecationSet = (name) => {
 	let initialized = false;
@@ -207,14 +204,15 @@ module.exports.createArrayToSetDeprecationSet = (name) => {
 	 */
 	class SetDeprecatedArray extends Set {
 		/**
-		 * @param {readonly T[] | null=} items items
+		 * @param {ReadonlyArray<T> | null=} items items
 		 */
 		constructor(items) {
 			super(items);
 			if (!initialized) {
 				initialized = true;
 				module.exports.arrayToSetDeprecation(
-					SetDeprecatedArray.prototype,
+					/** @type {SetWithDeprecatedArrayMethods<T>} */
+					(SetDeprecatedArray.prototype),
 					name
 				);
 			}