webpack 5.59.0 → 5.94.0

package/lib/util/compileBooleanMatcher.js

@@ -5,12 +5,18 @@
 
 "use strict";
 
-const quoteMeta = str => {
-	return str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
-};
+/**
+ * @param {string} str string
+ * @returns {string} quoted meta
+ */
+const quoteMeta = str => str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
 
+/**
+ * @param {string} str string
+ * @returns {string} string
+ */
 const toSimpleString = str => {
-	if (`${+str}` === str) {
+	if (`${Number(str)}` === str) {
 		return str;
 	}
 	return JSON.stringify(str);
@@ -18,7 +24,7 @@ const toSimpleString = str => {
 
 /**
  * @param {Record<string|number, boolean>} map value map
- * @returns {true|false|function(string): string} true/false, when unconditionally true/false, or a template function to determine the value at runtime
+ * @returns {boolean|(function(string): string)} true/false, when unconditionally true/false, or a template function to determine the value at runtime
  */
 const compileBooleanMatcher = map => {
 	const positiveItems = Object.keys(map).filter(i => map[i]);
@@ -44,24 +50,32 @@ const compileBooleanMatcherFromLists = (positiveItems, negativeItems) => {
 	const negativeRegexp = itemsToRegexp(negativeItems);
 	if (positiveRegexp.length <= negativeRegexp.length) {
 		return value => `/^${positiveRegexp}$/.test(${value})`;
-	} else {
-		return value => `!/^${negativeRegexp}$/.test(${value})`;
 	}
+	return value => `!/^${negativeRegexp}$/.test(${value})`;
 };
 
+/**
+ * @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
+ */
 const popCommonItems = (itemsSet, getKey, condition) => {
+	/** @type {Map<string, Array<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>} */
 				list = [];
 				map.set(key, list);
 			}
 			list.push(item);
 		}
 	}
+	/** @type {Array<Array<string>>} */
 	const result = [];
 	for (const list of map.values()) {
 		if (condition(list)) {
@@ -74,6 +88,10 @@ const popCommonItems = (itemsSet, getKey, condition) => {
 	return result;
 };
 
+/**
+ * @param {Array<string>} items items
+ * @returns {string} common prefix
+ */
 const getCommonPrefix = items => {
 	let prefix = items[0];
 	for (let i = 1; i < items.length; i++) {
@@ -88,6 +106,10 @@ const getCommonPrefix = items => {
 	return prefix;
 };
 
+/**
+ * @param {Array<string>} items items
+ * @returns {string} common suffix
+ */
 const getCommonSuffix = items => {
 	let suffix = items[0];
 	for (let i = 1; i < items.length; i++) {
@@ -102,10 +124,15 @@ const getCommonSuffix = items => {
 	return suffix;
 };
 
+/**
+ * @param {Array<string>} itemsArr array of items
+ * @returns {string} regexp
+ */
 const itemsToRegexp = itemsArr => {
 	if (itemsArr.length === 1) {
 		return quoteMeta(itemsArr[0]);
 	}
+	/** @type {Array<string>} */
 	const finishedItems = [];
 
 	// merge single char items: (a|b|c|d|ef) => ([abcd]|ef)
@@ -146,6 +173,7 @@ const itemsToRegexp = itemsArr => {
 
 	// special case for 2 items with common suffix
 	if (finishedItems.length === 0 && items.size === 2) {
+		/** @type {Iterator<string>} */
 		const it = items[Symbol.iterator]();
 		const a = it.next().value;
 		const b = it.next().value;

package/lib/util/conventions.js

@@ -0,0 +1,126 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Gengkun He @ahabhgk
+*/
+
+"use strict";
+
+/** @typedef {import("../../declarations/WebpackOptions").CssGeneratorExportsConvention} CssGeneratorExportsConvention */
+
+/**
+ * @param {string} input input
+ * @param {CssGeneratorExportsConvention | undefined} convention convention
+ * @returns {string[]} results
+ */
+module.exports.cssExportConvention = (input, convention) => {
+	const set = new Set();
+	if (typeof convention === "function") {
+		set.add(convention(input));
+	} else {
+		switch (convention) {
+			case "camel-case": {
+				set.add(input);
+				set.add(module.exports.camelCase(input));
+				break;
+			}
+			case "camel-case-only": {
+				set.add(module.exports.camelCase(input));
+				break;
+			}
+			case "dashes": {
+				set.add(input);
+				set.add(module.exports.dashesCamelCase(input));
+				break;
+			}
+			case "dashes-only": {
+				set.add(module.exports.dashesCamelCase(input));
+				break;
+			}
+			case "as-is": {
+				set.add(input);
+				break;
+			}
+		}
+	}
+	return Array.from(set);
+};
+
+// Copy from css-loader
+/**
+ * @param {string} input input
+ * @returns {string} result
+ */
+module.exports.dashesCamelCase = input =>
+	input.replace(/-+(\w)/g, (match, firstLetter) => firstLetter.toUpperCase());
+
+// Copy from css-loader
+/**
+ * @param {string} input input
+ * @returns {string} result
+ */
+module.exports.camelCase = input => {
+	let result = input.trim();
+
+	if (result.length === 0) {
+		return "";
+	}
+
+	if (result.length === 1) {
+		return result.toLowerCase();
+	}
+
+	const hasUpperCase = result !== result.toLowerCase();
+
+	if (hasUpperCase) {
+		result = preserveCamelCase(result);
+	}
+
+	return result
+		.replace(/^[_.\- ]+/, "")
+		.toLowerCase()
+		.replace(/[_.\- ]+([\p{Alpha}\p{N}_]|$)/gu, (_, p1) => p1.toUpperCase())
+		.replace(/\d+([\p{Alpha}\p{N}_]|$)/gu, m => m.toUpperCase());
+};
+
+// Copy from css-loader
+/**
+ * @param {string} string string
+ * @returns {string} result
+ */
+const preserveCamelCase = string => {
+	let result = string;
+	let isLastCharLower = false;
+	let isLastCharUpper = false;
+	let isLastLastCharUpper = false;
+
+	for (let i = 0; i < result.length; i++) {
+		const character = result[i];
+
+		if (isLastCharLower && /[\p{Lu}]/u.test(character)) {
+			result = `${result.slice(0, i)}-${result.slice(i)}`;
+			isLastCharLower = false;
+			isLastLastCharUpper = isLastCharUpper;
+			isLastCharUpper = true;
+			i += 1;
+		} else if (
+			isLastCharUpper &&
+			isLastLastCharUpper &&
+			/[\p{Ll}]/u.test(character)
+		) {
+			result = `${result.slice(0, i - 1)}-${result.slice(i - 1)}`;
+			isLastLastCharUpper = isLastCharUpper;
+			isLastCharUpper = false;
+			isLastCharLower = true;
+		} else {
+			isLastCharLower =
+				character.toLowerCase() === character &&
+				character.toUpperCase() !== character;
+			isLastLastCharUpper = isLastCharUpper;
+			isLastCharUpper =
+				character.toUpperCase() === character &&
+				character.toLowerCase() !== character;
+		}
+	}
+
+	return result;
+};

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

@@ -9,11 +9,18 @@ const memoize = require("./memoize");
 
 const getValidate = memoize(() => require("schema-utils").validate);
 
-const createSchemaValidation = (check = v => false, getSchema, options) => {
+const createSchemaValidation = (check, getSchema, options) => {
 	getSchema = memoize(getSchema);
 	return value => {
-		if (!check(value)) {
+		if (check && !check(value)) {
 			getValidate()(getSchema(), value, options);
+			if (check) {
+				require("util").deprecate(
+					() => {},
+					"webpack bug: Pre-compiled schema reports error while real schema is happy. This has performance drawbacks.",
+					"DEP_WEBPACK_PRE_COMPILED_SCHEMA_INVALID"
+				)();
+			}
 		}
 	};
 };

package/lib/util/createHash.js

@@ -11,11 +11,14 @@ 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 | function(): Hash} hashOrFactory function to create a hash
+	 * @param {Hash | HashFactory} hashOrFactory function to create a hash
 	 * @param {string=} hashKey key for caching
 	 */
 	constructor(hashOrFactory, hashKey) {
@@ -43,7 +46,8 @@ class BulkUpdateDecorator extends Hash {
 			typeof data !== "string" ||
 			data.length > BULK_SIZE
 		) {
-			if (this.hash === undefined) this.hash = this.hashFactory();
+			if (this.hash === undefined)
+				this.hash = /** @type {HashFactory} */ (this.hashFactory)();
 			if (this.buffer.length > 0) {
 				this.hash.update(this.buffer);
 				this.buffer = "";
@@ -52,7 +56,8 @@ class BulkUpdateDecorator extends Hash {
 		} else {
 			this.buffer += data;
 			if (this.buffer.length > BULK_SIZE) {
-				if (this.hash === undefined) this.hash = this.hashFactory();
+				if (this.hash === undefined)
+					this.hash = /** @type {HashFactory} */ (this.hashFactory)();
 				this.hash.update(this.buffer);
 				this.buffer = "";
 			}
@@ -77,7 +82,7 @@ class BulkUpdateDecorator extends Hash {
 			}
 			const cacheEntry = digestCache.get(buffer);
 			if (cacheEntry !== undefined) return cacheEntry;
-			this.hash = this.hashFactory();
+			this.hash = /** @type {HashFactory} */ (this.hashFactory)();
 		}
 		if (buffer.length > 0) {
 			this.hash.update(buffer);
@@ -107,10 +112,13 @@ class DebugHash extends Hash {
 	 */
 	update(data, inputEncoding) {
 		if (typeof data !== "string") data = data.toString("utf-8");
-		if (data.startsWith("debug-digest-")) {
-			data = Buffer.from(data.slice("debug-digest-".length), "hex").toString();
+		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}](${new Error().stack.split("\n", 3)[2]})\n`;
+		this.string += `[${data}](${
+			/** @type {string} */ (new Error().stack).split("\n", 3)[2]
+		})\n`;
 		return this;
 	}
 
@@ -120,21 +128,29 @@ class DebugHash extends Hash {
 	 * @returns {string|Buffer} digest
 	 */
 	digest(encoding) {
-		return "debug-digest-" + Buffer.from(this.string).toString("hex");
+		return Buffer.from(`@webpack-debug-digest@${this.string}`).toString("hex");
 	}
 }
 
-let crypto = undefined;
-let createXXHash64 = undefined;
-let BatchedHash = undefined;
+/** @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/BatchedHash") | undefined} */
+let BatchedHash;
+
+/** @typedef {string | typeof Hash} Algorithm */
 
 /**
  * Creates a hash by name or function
- * @param {string | typeof Hash} algorithm the algorithm name or a constructor creating a hash
+ * @param {Algorithm} algorithm the algorithm name or a constructor creating a hash
  * @returns {Hash} the hash
  */
 module.exports = algorithm => {
 	if (typeof algorithm === "function") {
+		// eslint-disable-next-line new-cap
 		return new BulkUpdateDecorator(() => new algorithm());
 	}
 	switch (algorithm) {
@@ -148,11 +164,30 @@ module.exports = algorithm => {
 					BatchedHash = require("./hash/BatchedHash");
 				}
 			}
-			return new BatchedHash(createXXHash64());
+			return new /** @type {typeof import("./hash/BatchedHash")} */ (
+				BatchedHash
+			)(createXXHash64());
+		case "md4":
+			if (createMd4 === undefined) {
+				createMd4 = require("./hash/md4");
+				if (BatchedHash === undefined) {
+					BatchedHash = require("./hash/BatchedHash");
+				}
+			}
+			return new /** @type {typeof import("./hash/BatchedHash")} */ (
+				BatchedHash
+			)(createMd4());
+		case "native-md4":
+			if (crypto === undefined) crypto = require("crypto");
+			return new BulkUpdateDecorator(
+				() => /** @type {typeof import("crypto")} */ (crypto).createHash("md4"),
+				"md4"
+			);
 		default:
 			if (crypto === undefined) crypto = require("crypto");
 			return new BulkUpdateDecorator(
-				() => crypto.createHash(algorithm),
+				() =>
+					/** @type {typeof import("crypto")} */ (crypto).createHash(algorithm),
 				algorithm
 			);
 	}

package/lib/util/deprecation.js

@@ -11,11 +11,14 @@ const util = require("util");
 const deprecationCache = new Map();
 
 /**
- * @typedef {Object} FakeHookMarker
+ * @typedef {object} FakeHookMarker
  * @property {true} _fakeHook it's a fake hook
  */
 
-/** @template T @typedef {T & FakeHookMarker} FakeHook<T> */
+/**
+ * @template T
+ * @typedef {T & FakeHookMarker} FakeHook<T>
+ */
 
 /**
  * @param {string} message deprecation message
@@ -28,7 +31,7 @@ const createDeprecation = (message, code) => {
 	const fn = util.deprecate(
 		() => {},
 		message,
-		"DEP_WEBPACK_DEPRECATION_" + code
+		`DEP_WEBPACK_DEPRECATION_${code}`
 	);
 	deprecationCache.set(message, fn);
 	return fn;
@@ -69,7 +72,7 @@ const DISABLED_METHODS = [
  * @param {string} name property name
  * @returns {void}
  */
-exports.arrayToSetDeprecation = (set, name) => {
+module.exports.arrayToSetDeprecation = (set, name) => {
 	for (const method of COPY_METHODS) {
 		if (set[method]) continue;
 		const d = createDeprecation(
@@ -78,13 +81,17 @@ exports.arrayToSetDeprecation = (set, name) => {
 		);
 		/**
 		 * @deprecated
-		 * @this {Set}
+		 * @this {Set<any>}
 		 * @returns {number} count
 		 */
 		set[method] = function () {
 			d();
 			const array = Array.from(this);
-			return Array.prototype[method].apply(array, arguments);
+			return Array.prototype[/** @type {keyof COPY_METHODS} */ (method)].apply(
+				array,
+				// eslint-disable-next-line prefer-rest-params
+				arguments
+			);
 		};
 	}
 	const dPush = createDeprecation(
@@ -101,11 +108,12 @@ exports.arrayToSetDeprecation = (set, name) => {
 	);
 	/**
 	 * @deprecated
-	 * @this {Set}
+	 * @this {Set<any>}
 	 * @returns {number} count
 	 */
 	set.push = function () {
 		dPush();
+		// eslint-disable-next-line prefer-rest-params
 		for (const item of Array.from(arguments)) {
 			this.add(item);
 		}
@@ -119,21 +127,28 @@ exports.arrayToSetDeprecation = (set, name) => {
 			);
 		};
 	}
+	/**
+	 * @param {number} index index
+	 * @returns {any} value
+	 */
 	const createIndexGetter = index => {
 		/**
-		 * @this {Set} a Set
+		 * @this {Set<any>} a Set
 		 * @returns {any} the value at this location
 		 */
+		// eslint-disable-next-line func-style
 		const fn = function () {
 			dIndexer();
 			let i = 0;
 			for (const item of this) {
 				if (i++ === index) return item;
 			}
-			return undefined;
 		};
 		return fn;
 	};
+	/**
+	 * @param {number} index index
+	 */
 	const defineIndexGetter = index => {
 		Object.defineProperty(set, index, {
 			get: createIndexGetter(index),
@@ -164,13 +179,31 @@ exports.arrayToSetDeprecation = (set, name) => {
 	set[Symbol.isConcatSpreadable] = true;
 };
 
-exports.createArrayToSetDeprecationSet = name => {
-	class SetDeprecatedArray extends Set {}
-	exports.arrayToSetDeprecation(SetDeprecatedArray.prototype, name);
+module.exports.createArrayToSetDeprecationSet = name => {
+	let initialized = false;
+	class SetDeprecatedArray extends Set {
+		constructor(items) {
+			super(items);
+			if (!initialized) {
+				initialized = true;
+				module.exports.arrayToSetDeprecation(
+					SetDeprecatedArray.prototype,
+					name
+				);
+			}
+		}
+	}
 	return SetDeprecatedArray;
 };
 
-exports.soonFrozenObjectDeprecation = (obj, name, code, note = "") => {
+/**
+ * @param {object} obj object
+ * @param {string} name property name
+ * @param {string} code deprecation code
+ * @param {string} note additional note
+ * @returns {Proxy<object>} frozen object with deprecation when modifying
+ */
+module.exports.soonFrozenObjectDeprecation = (obj, name, code, note = "") => {
 	const message = `${name} will be frozen in future, all modifications are deprecated.${
 		note && `\n${note}`
 	}`;
@@ -237,7 +270,7 @@ const deprecateAllProperties = (obj, message, code) => {
 	}
 	return /** @type {T} */ (newObj);
 };
-exports.deprecateAllProperties = deprecateAllProperties;
+module.exports.deprecateAllProperties = deprecateAllProperties;
 
 /**
  * @template T
@@ -246,7 +279,7 @@ exports.deprecateAllProperties = deprecateAllProperties;
  * @param {string=} code deprecation code (not deprecated when unset)
  * @returns {FakeHook<T>} fake hook which redirects
  */
-exports.createFakeHook = (fakeHook, message, code) => {
+module.exports.createFakeHook = (fakeHook, message, code) => {
 	if (message && code) {
 		fakeHook = deprecateAllProperties(fakeHook, message, code);
 	}