webpack 5.97.1 → 5.104.1

package/lib/util/compileBooleanMatcher.js

@@ -9,13 +9,86 @@
  * @param {string} str string
  * @returns {string} quoted meta
  */
-const quoteMeta = str => str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
+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
  */
-const toSimpleString = str => {
+const toSimpleString = (str) => {
 	if (`${Number(str)}` === str) {
 		return str;
 	}
@@ -23,12 +96,12 @@ const toSimpleString = str => {
 };
 
 /**
- * @param {Record<string|number, boolean>} map value map
- * @returns {boolean|(function(string): string)} true/false, when unconditionally true/false, or a template function to determine the value at runtime
+ * @param {Record<string | number, boolean>} map value map
+ * @returns {boolean | ((value: 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]);
-	const negativeItems = Object.keys(map).filter(i => !map[i]);
+const compileBooleanMatcher = (map) => {
+	const positiveItems = Object.keys(map).filter((i) => map[i]);
+	const negativeItems = Object.keys(map).filter((i) => !map[i]);
 	if (positiveItems.length === 0) return false;
 	if (negativeItems.length === 0) return true;
 	return compileBooleanMatcherFromLists(positiveItems, negativeItems);
@@ -37,45 +110,49 @@ const compileBooleanMatcher = map => {
 /**
  * @param {string[]} positiveItems positive items
  * @param {string[]} negativeItems negative items
- * @returns {function(string): string} a template function to determine the value at runtime
+ * @returns {(value: string) => string} a template function to determine the value at runtime
  */
 const compileBooleanMatcherFromLists = (positiveItems, negativeItems) => {
 	if (positiveItems.length === 0) return () => "false";
 	if (negativeItems.length === 0) return () => "true";
-	if (positiveItems.length === 1)
-		return value => `${toSimpleString(positiveItems[0])} == ${value}`;
-	if (negativeItems.length === 1)
-		return value => `${toSimpleString(negativeItems[0])} != ${value}`;
+	if (positiveItems.length === 1) {
+		return (value) => `${toSimpleString(positiveItems[0])} == ${value}`;
+	}
+	if (negativeItems.length === 1) {
+		return (value) => `${toSimpleString(negativeItems[0])} != ${value}`;
+	}
 	const positiveRegexp = itemsToRegexp(positiveItems);
 	const negativeRegexp = itemsToRegexp(negativeItems);
 	if (positiveRegexp.length <= negativeRegexp.length) {
-		return value => `/^${positiveRegexp}$/.test(${value})`;
+		return (value) => `/^${positiveRegexp}$/.test(${value})`;
 	}
-	return value => `!/^${negativeRegexp}$/.test(${value})`;
+	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)) {
@@ -89,10 +166,10 @@ const popCommonItems = (itemsSet, getKey, condition) => {
 };
 
 /**
- * @param {Array<string>} items items
+ * @param {string[]} items items
  * @returns {string} common prefix
  */
-const getCommonPrefix = items => {
+const getCommonPrefix = (items) => {
 	let prefix = items[0];
 	for (let i = 1; i < items.length; i++) {
 		const item = items[i];
@@ -107,10 +184,10 @@ const getCommonPrefix = items => {
 };
 
 /**
- * @param {Array<string>} items items
+ * @param {string[]} items items
  * @returns {string} common suffix
  */
-const getCommonSuffix = items => {
+const getCommonSuffix = (items) => {
 	let suffix = items[0];
 	for (let i = 1; i < items.length; i++) {
 		const item = items[i];
@@ -125,14 +202,14 @@ const getCommonSuffix = items => {
 };
 
 /**
- * @param {Array<string>} itemsArr array of items
+ * @param {string[]} itemsArr array of items
  * @returns {string} regexp
  */
-const itemsToRegexp = itemsArr => {
+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)
@@ -144,29 +221,31 @@ 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
 	if (finishedItems.length === 0 && items.size === 2) {
 		const prefix = getCommonPrefix(itemsArr);
 		const suffix = getCommonSuffix(
-			itemsArr.map(item => item.slice(prefix.length))
+			itemsArr.map((item) => item.slice(prefix.length))
 		);
 		if (prefix.length > 0 || suffix.length > 0) {
 			return `${quoteMeta(prefix)}${itemsToRegexp(
-				itemsArr.map(i => i.slice(prefix.length, -suffix.length || undefined))
+				itemsArr.map((i) => i.slice(prefix.length, -suffix.length || undefined))
 			)}${quoteMeta(suffix)}`;
 		}
 	}
@@ -187,8 +266,8 @@ const itemsToRegexp = itemsArr => {
 	// find common prefix: (a1|a2|a3|a4|b5) => (a(1|2|3|4)|b5)
 	const prefixed = popCommonItems(
 		items,
-		item => (item.length >= 1 ? item[0] : false),
-		list => {
+		(item) => (item.length >= 1 ? item[0] : false),
+		(list) => {
 			if (list.length >= 3) return true;
 			if (list.length <= 1) return false;
 			return list[0][1] === list[1][1];
@@ -198,7 +277,7 @@ const itemsToRegexp = itemsArr => {
 		const prefix = getCommonPrefix(prefixedItems);
 		finishedItems.push(
 			`${quoteMeta(prefix)}${itemsToRegexp(
-				prefixedItems.map(i => i.slice(prefix.length))
+				prefixedItems.map((i) => i.slice(prefix.length))
 			)}`
 		);
 	}
@@ -206,8 +285,8 @@ const itemsToRegexp = itemsArr => {
 	// find common suffix: (a1|b1|c1|d1|e2) => ((a|b|c|d)1|e2)
 	const suffixed = popCommonItems(
 		items,
-		item => (item.length >= 1 ? item.slice(-1) : false),
-		list => {
+		(item) => (item.length >= 1 ? item.slice(-1) : false),
+		(list) => {
 			if (list.length >= 3) return true;
 			if (list.length <= 1) return false;
 			return list[0].slice(-2) === list[1].slice(-2);
@@ -217,18 +296,18 @@ const itemsToRegexp = itemsArr => {
 		const suffix = getCommonSuffix(suffixedItems);
 		finishedItems.push(
 			`${itemsToRegexp(
-				suffixedItems.map(i => i.slice(0, -suffix.length))
+				suffixedItems.map((i) => i.slice(0, -suffix.length))
 			)}${quoteMeta(suffix)}`
 		);
 	}
 
-	// TODO further optimize regexp, i. e.
-	// use ranges: (1|2|3|4|a) => [1-4a]
-	const conditional = finishedItems.concat(Array.from(items, quoteMeta));
+	/** @type {string[]} */
+	const conditional = [...finishedItems, ...Array.from(items, quoteMeta)];
 	if (conditional.length === 1) return conditional[0];
 	return `(${conditional.join("|")})`;
 };
 
 compileBooleanMatcher.fromLists = compileBooleanMatcherFromLists;
 compileBooleanMatcher.itemsToRegexp = itemsToRegexp;
+
 module.exports = compileBooleanMatcher;

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__";
@@ -22,14 +21,14 @@ const NAMESPACE_OBJECT_EXPORT = "__WEBPACK_NAMESPACE_OBJECT__";
  * @param {Variable} variable variable
  * @returns {Reference[]} references
  */
-const getAllReferences = variable => {
+const getAllReferences = (variable) => {
 	let set = variable.references;
 	// Look for inner scope variables too (like in class Foo { t() { Foo } })
 	const identifiers = new Set(variable.identifiers);
 	for (const scope of variable.scope.childScopes) {
 		for (const innerVar of scope.variables) {
-			if (innerVar.identifiers.some(id => identifiers.has(id))) {
-				set = set.concat(innerVar.references);
+			if (innerVar.identifiers.some((id) => identifiers.has(id))) {
+				set = [...set, ...innerVar.references];
 				break;
 			}
 		}
@@ -53,7 +52,7 @@ const getPathInAst = (ast, node) => {
 	 * @param {Node} n node
 	 * @returns {Node[] | undefined} result
 	 */
-	const enterNode = n => {
+	const enterNode = (n) => {
 		if (!n) return;
 		const r = n.range;
 		if (r && r[0] <= nr[0] && r[1] >= nr[1]) {
@@ -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`
@@ -122,8 +121,9 @@ function findNewName(oldName, usedNamed1, usedNamed2, extraInfo) {
 		if (
 			!usedNamed1.has(nameIdent) &&
 			(!usedNamed2 || !usedNamed2.has(nameIdent))
-		)
+		) {
 			return nameIdent;
+		}
 	}
 
 	let i = 0;
@@ -139,11 +139,13 @@ function findNewName(oldName, usedNamed1, usedNamed2, extraInfo) {
 	return nameWithNumber;
 }
 
+/** @typedef {Set<Scope>} ScopeSet */
+
 /**
  * @param {Scope | null} s scope
  * @param {UsedNames} nameSet name set
- * @param {TODO} scopeSet1 scope set 1
- * @param {TODO} scopeSet2 scope set 2
+ * @param {ScopeSet} scopeSet1 scope set 1
+ * @param {ScopeSet} scopeSet2 scope set 2
  */
 const addScopeSymbols = (s, nameSet, scopeSet1, scopeSet2) => {
 	let scope = s;
@@ -196,11 +198,13 @@ const RESERVED_NAMES = new Set(
 		.split(",")
 );
 
+/** @typedef {{ usedNames: UsedNames, alreadyCheckedScopes: ScopeSet }} ScopeInfo */
+
 /**
- * @param {Map<string, { usedNames: UsedNames, alreadyCheckedScopes: Set<TODO> }>} usedNamesInScopeInfo used names in scope info
+ * @param {Map<string, ScopeInfo>} usedNamesInScopeInfo used names in scope info
  * @param {string} module module identifier
  * @param {string} id export id
- * @returns {{ usedNames: UsedNames, alreadyCheckedScopes: Set<TODO> }} info
+ * @returns {ScopeInfo} info
  */
 const getUsedNamesInScopeInfo = (usedNamesInScopeInfo, module, id) => {
 	const key = `${module}-${id}`;
@@ -216,12 +220,12 @@ const getUsedNamesInScopeInfo = (usedNamesInScopeInfo, module, id) => {
 };
 
 module.exports = {
-	getUsedNamesInScopeInfo,
+	DEFAULT_EXPORT,
+	NAMESPACE_OBJECT_EXPORT,
+	RESERVED_NAMES,
+	addScopeSymbols,
 	findNewName,
 	getAllReferences,
 	getPathInAst,
-	NAMESPACE_OBJECT_EXPORT,
-	DEFAULT_EXPORT,
-	RESERVED_NAMES,
-	addScopeSymbols
+	getUsedNamesInScopeInfo
 };

package/lib/util/conventions.js

@@ -6,6 +6,77 @@
 "use strict";
 
 /** @typedef {import("../../declarations/WebpackOptions").CssGeneratorExportsConvention} CssGeneratorExportsConvention */
+// 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;
+};
+
+// 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());
+};
 
 /**
  * @param {string} input input
@@ -42,7 +113,7 @@ module.exports.cssExportConvention = (input, convention) => {
 			}
 		}
 	}
-	return Array.from(set);
+	return [...set];
 };
 
 // Copy from css-loader
@@ -50,77 +121,5 @@ module.exports.cssExportConvention = (input, convention) => {
  * @param {string} input input
  * @returns {string} result
  */
-module.exports.dashesCamelCase = input =>
+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

@@ -7,25 +7,25 @@
 
 const memoize = require("./memoize");
 
-/** @typedef {import("schema-utils/declarations/validate").ValidationErrorConfiguration} ValidationErrorConfiguration */
-/** @typedef {import("./fs").JsonObject} JsonObject */
+/** @typedef {import("schema-utils").Schema} Schema */
+/** @typedef {import("schema-utils").ValidationErrorConfiguration} ValidationErrorConfiguration */
 
 const getValidate = memoize(() => require("schema-utils").validate);
 
 /**
  * @template {object | object[]} T
- * @param {(function(T): boolean) | undefined} check check
- * @param {() => JsonObject} getSchema get schema fn
+ * @param {((value: T) => boolean) | undefined} check check
+ * @param {() => Schema} getSchema get schema fn
  * @param {ValidationErrorConfiguration} options options
- * @returns {function(T=): void} validate
+ * @returns {(value?: T) => void} validate
  */
 const createSchemaValidation = (check, getSchema, options) => {
 	getSchema = memoize(getSchema);
-	return value => {
-		if (check && !check(/** @type {T} */ (value))) {
+	return (value) => {
+		if (check && value && !check(value)) {
 			getValidate()(
 				getSchema(),
-				/** @type {object | object[]} */
+				/** @type {EXPECTED_OBJECT | EXPECTED_OBJECT[]} */
 				(value),
 				options
 			);