webpack 5.97.1 → 5.104.1

package/lib/util/createHash.js

@@ -5,132 +5,8 @@
 
 "use strict";
 
-const Hash = require("./Hash");
-
-const BULK_SIZE = 2000;
-
-// 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 {function(): 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}
-	 * @param {string|Buffer} data data
-	 * @param {string=} inputEncoding data encoding
-	 * @returns {this} 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 = "";
-			}
-			this.hash.update(data, inputEncoding);
-		} 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}
-	 * @param {string=} 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);
-		}
-		const digestResult = this.hash.digest(encoding);
-		const result =
-			typeof digestResult === "string" ? digestResult : 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}
-	 * @param {string|Buffer} data data
-	 * @param {string=} inputEncoding data encoding
-	 * @returns {this} updated hash
-	 */
-	update(data, inputEncoding) {
-		if (typeof data !== "string") data = data.toString("utf-8");
-		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} */ (new Error().stack).split("\n", 3)[2]
-		})\n`;
-		return this;
-	}
-
-	/**
-	 * 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
-	 */
-	digest(encoding) {
-		return Buffer.from(`@webpack-debug-digest@${this.string}`).toString("hex");
-	}
-}
+/** @typedef {import("./Hash")} Hash */
+/** @typedef {import("../../declarations/WebpackOptions").HashFunction} HashFunction */
 
 /** @type {typeof import("crypto") | undefined} */
 let crypto;
@@ -138,24 +14,32 @@ let crypto;
 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;
-
-/** @typedef {string | typeof Hash} Algorithm */
+/** @type {typeof import("./hash/BulkUpdateHash") | undefined} */
+let BulkUpdateHash;
 
 /**
  * Creates a hash by name or function
- * @param {Algorithm} algorithm the algorithm name or a constructor creating a hash
+ * @param {HashFunction} algorithm the algorithm name or a constructor creating a hash
  * @returns {Hash} the hash
  */
-module.exports = algorithm => {
+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) {
@@ -179,15 +63,28 @@ module.exports = algorithm => {
 			)(createMd4());
 		case "native-md4":
 			if (crypto === undefined) crypto = require("crypto");
-			return new BulkUpdateDecorator(
-				() => /** @type {typeof import("crypto")} */ (crypto).createHash("md4"),
+			if (BulkUpdateHash === undefined) {
+				BulkUpdateHash = require("./hash/BulkUpdateHash");
+			}
+			return new BulkUpdateHash(
+				() =>
+					/** @type {Hash} */ (
+						/** @type {typeof import("crypto")} */
+						(crypto).createHash("md4")
+					),
 				"md4"
 			);
 		default:
 			if (crypto === undefined) crypto = require("crypto");
-			return new BulkUpdateDecorator(
+			if (BulkUpdateHash === undefined) {
+				BulkUpdateHash = require("./hash/BulkUpdateHash");
+			}
+			return new BulkUpdateHash(
 				() =>
-					/** @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

@@ -7,7 +7,7 @@
 
 const util = require("util");
 
-/** @type {Map<string, Function>} */
+/** @type {Map<string, () => void>} */
 const deprecationCache = new Map();
 
 /**
@@ -23,7 +23,7 @@ const deprecationCache = new Map();
 /**
  * @param {string} message deprecation message
  * @param {string} code deprecation code
- * @returns {Function} function to trigger deprecation
+ * @returns {() => void} function to trigger deprecation
  */
 const createDeprecation = (message, code) => {
 	const cached = deprecationCache.get(message);
@@ -37,6 +37,9 @@ const createDeprecation = (message, code) => {
 	return fn;
 };
 
+/** @typedef {"concat" | "entry" | "filter" | "find" | "findIndex" | "includes" | "indexOf" | "join" | "lastIndexOf" | "map" | "reduce" | "reduceRight" | "slice" | "some"} COPY_METHODS_NAMES */
+
+/** @type {COPY_METHODS_NAMES[]} */
 const COPY_METHODS = [
 	"concat",
 	"entry",
@@ -54,6 +57,9 @@ const COPY_METHODS = [
 	"some"
 ];
 
+/** @typedef {"copyWithin" | "entries" | "fill" | "keys" | "pop" | "reverse" | "shift" | "splice" | "sort" | "unshift"} DISABLED_METHODS_NAMES */
+
+/** @type {DISABLED_METHODS_NAMES[]} */
 const DISABLED_METHODS = [
 	"copyWithin",
 	"entries",
@@ -68,31 +74,38 @@ const DISABLED_METHODS = [
 ];
 
 /**
- * @param {any} set new set
+ * @template T
+ * @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 {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<any>}
-		 * @returns {number} count
-		 */
-		set[method] = function () {
-			d();
-			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)`,
@@ -106,22 +119,20 @@ module.exports.arrayToSetDeprecation = (set, name) => {
 		`${name} was changed from Array to Set (indexing Array is deprecated)`,
 		"ARRAY_TO_SET_INDEXER"
 	);
-	/**
-	 * @deprecated
-	 * @this {Set<any>}
-	 * @returns {number} count
-	 */
-	set.push = function () {
+	/** @type {SetWithDeprecatedArrayMethods<T>} */
+	(set).push = function push() {
 		dPush();
-		// eslint-disable-next-line prefer-rest-params
+		// eslint-disable-next-line prefer-rest-params, unicorn/prefer-spread
 		for (const item of Array.from(arguments)) {
 			this.add(item);
 		}
 		return this.size;
 	};
 	for (const method of DISABLED_METHODS) {
-		if (set[method]) continue;
-		set[method] = () => {
+		if (/** @type {SetWithDeprecatedArrayMethods<T>} */ (set)[method]) continue;
+
+		/** @type {SetWithDeprecatedArrayMethods<T>} */
+		(set)[method] = () => {
 			throw new Error(
 				`${name} was changed from Array to Set (using Array method '${method}' is not possible)`
 			);
@@ -129,12 +140,12 @@ module.exports.arrayToSetDeprecation = (set, name) => {
 	}
 	/**
 	 * @param {number} index index
-	 * @returns {any} value
+	 * @returns {() => T | undefined} value
 	 */
-	const createIndexGetter = index => {
+	const createIndexGetter = (index) => {
 		/**
-		 * @this {Set<any>} a Set
-		 * @returns {any} the value at this location
+		 * @this {Set<T>} a Set
+		 * @returns {T | undefined} the value at this location
 		 */
 		// eslint-disable-next-line func-style
 		const fn = function () {
@@ -149,7 +160,7 @@ module.exports.arrayToSetDeprecation = (set, name) => {
 	/**
 	 * @param {number} index index
 	 */
-	const defineIndexGetter = index => {
+	const defineIndexGetter = (index) => {
 		Object.defineProperty(set, index, {
 			get: createIndexGetter(index),
 			set(value) {
@@ -176,15 +187,16 @@ 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 = EXPECTED_ANY>(values?: ReadonlyArray<T> | null): SetDeprecatedArray<T> }} SetDeprecatedArray
  */
-module.exports.createArrayToSetDeprecationSet = name => {
+module.exports.createArrayToSetDeprecationSet = (name) => {
 	let initialized = false;
 
 	/**
@@ -192,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
 				);
 			}
@@ -210,75 +223,17 @@ module.exports.createArrayToSetDeprecationSet = name => {
 
 /**
  * @template {object} T
- * @param {T} obj object
- * @param {string} name property name
- * @param {string} code deprecation code
- * @param {string} note additional note
- * @returns {Proxy<T>} frozen object with deprecation when modifying
+ * @param {T} fakeHook fake hook implementation
+ * @param {string=} message deprecation message (not deprecated when unset)
+ * @param {string=} code deprecation code (not deprecated when unset)
+ * @returns {FakeHook<T>} fake hook which redirects
  */
-module.exports.soonFrozenObjectDeprecation = (obj, name, code, note = "") => {
-	const message = `${name} will be frozen in future, all modifications are deprecated.${
-		note && `\n${note}`
-	}`;
-	return /** @type {Proxy<T>} */ (
-		new Proxy(/** @type {object} */ (obj), {
-			set: util.deprecate(
-				/**
-				 * @param {T} target target
-				 * @param {string | symbol} property property
-				 * @param {any} value value
-				 * @param {any} receiver receiver
-				 * @returns {boolean} result
-				 */
-				(target, property, value, receiver) =>
-					Reflect.set(
-						/** @type {object} */ (target),
-						property,
-						value,
-						receiver
-					),
-				message,
-				code
-			),
-			defineProperty: util.deprecate(
-				/**
-				 * @param {T} target target
-				 * @param {string | symbol} property property
-				 * @param {PropertyDescriptor} descriptor descriptor
-				 * @returns {boolean} result
-				 */
-				(target, property, descriptor) =>
-					Reflect.defineProperty(
-						/** @type {object} */ (target),
-						property,
-						descriptor
-					),
-				message,
-				code
-			),
-			deleteProperty: util.deprecate(
-				/**
-				 * @param {T} target target
-				 * @param {string | symbol} property property
-				 * @returns {boolean} result
-				 */
-				(target, property) =>
-					Reflect.deleteProperty(/** @type {object} */ (target), property),
-				message,
-				code
-			),
-			setPrototypeOf: util.deprecate(
-				/**
-				 * @param {T} target target
-				 * @param {object | null} proto proto
-				 * @returns {boolean} result
-				 */
-				(target, proto) =>
-					Reflect.setPrototypeOf(/** @type {object} */ (target), proto),
-				message,
-				code
-			)
-		})
+module.exports.createFakeHook = (fakeHook, message, code) => {
+	if (message && code) {
+		fakeHook = deprecateAllProperties(fakeHook, message, code);
+	}
+	return Object.freeze(
+		Object.assign(fakeHook, { _fakeHook: /** @type {true} */ (true) })
 	);
 };
 
@@ -318,7 +273,7 @@ const deprecateAllProperties = (obj, message, code) => {
 							 * @param {T} v value
 							 * @returns {T} result
 							 */
-							v => (value = v),
+							(v) => (value = v),
 							message,
 							code
 						)
@@ -328,20 +283,68 @@ const deprecateAllProperties = (obj, message, code) => {
 	}
 	return /** @type {T} */ (newObj);
 };
+
 module.exports.deprecateAllProperties = deprecateAllProperties;
 
 /**
  * @template {object} T
- * @param {T} fakeHook fake hook implementation
- * @param {string=} message deprecation message (not deprecated when unset)
- * @param {string=} code deprecation code (not deprecated when unset)
- * @returns {FakeHook<T>} fake hook which redirects
+ * @param {T} obj object
+ * @param {string} name property name
+ * @param {string} code deprecation code
+ * @param {string} note additional note
+ * @returns {T} frozen object with deprecation when modifying
  */
-module.exports.createFakeHook = (fakeHook, message, code) => {
-	if (message && code) {
-		fakeHook = deprecateAllProperties(fakeHook, message, code);
-	}
-	return Object.freeze(
-		Object.assign(fakeHook, { _fakeHook: /** @type {true} */ (true) })
+module.exports.soonFrozenObjectDeprecation = (obj, name, code, note = "") => {
+	const message = `${name} will be frozen in future, all modifications are deprecated.${
+		note && `\n${note}`
+	}`;
+	return /** @type {T} */ (
+		new Proxy(obj, {
+			set: util.deprecate(
+				/**
+				 * @param {object} target target
+				 * @param {string | symbol} property property
+				 * @param {EXPECTED_ANY} value value
+				 * @param {EXPECTED_ANY} receiver receiver
+				 * @returns {boolean} result
+				 */
+				(target, property, value, receiver) =>
+					Reflect.set(target, property, value, receiver),
+				message,
+				code
+			),
+			defineProperty: util.deprecate(
+				/**
+				 * @param {object} target target
+				 * @param {string | symbol} property property
+				 * @param {PropertyDescriptor} descriptor descriptor
+				 * @returns {boolean} result
+				 */
+				(target, property, descriptor) =>
+					Reflect.defineProperty(target, property, descriptor),
+				message,
+				code
+			),
+			deleteProperty: util.deprecate(
+				/**
+				 * @param {object} target target
+				 * @param {string | symbol} property property
+				 * @returns {boolean} result
+				 */
+				(target, property) => Reflect.deleteProperty(target, property),
+				message,
+				code
+			),
+			setPrototypeOf: util.deprecate(
+				/**
+				 * @param {object} target target
+				 * @param {EXPECTED_OBJECT | null} proto proto
+				 * @returns {boolean} result
+				 */
+				(target, proto) => Reflect.setPrototypeOf(target, proto),
+				message,
+				code
+			)
+		})
 	);
 };