webpack 5.101.3 → 5.102.0

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

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

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
 				);
 			}

package/lib/util/deterministicGrouping.js

@@ -70,9 +70,11 @@ const getName = (a, b, usedNames) => {
 	return a;
 };
 
+/** @typedef {Record<string, number>} Sizes */
+
 /**
- * @param {Record<string, number>} total total size
- * @param {Record<string, number>} size single size
+ * @param {Sizes} total total size
+ * @param {Sizes} size single size
  * @returns {void}
  */
 const addSizeTo = (total, size) => {
@@ -82,8 +84,8 @@ const addSizeTo = (total, size) => {
 };
 
 /**
- * @param {Record<string, number>} total total size
- * @param {Record<string, number>} size single size
+ * @param {Sizes} total total size
+ * @param {Sizes} size single size
  * @returns {void}
  */
 const subtractSizeFrom = (total, size) => {
@@ -95,7 +97,7 @@ const subtractSizeFrom = (total, size) => {
 /**
  * @template T
  * @param {Iterable<Node<T>>} nodes some nodes
- * @returns {Record<string, number>} total size
+ * @returns {Sizes} total size
  */
 const sumSize = (nodes) => {
 	const sum = Object.create(null);
@@ -106,8 +108,8 @@ const sumSize = (nodes) => {
 };
 
 /**
- * @param {Record<string, number>} size size
- * @param {Record<string, number>} maxSize minimum size
+ * @param {Sizes} size size
+ * @param {Sizes} maxSize minimum size
  * @returns {boolean} true, when size is too big
  */
 const isTooBig = (size, maxSize) => {
@@ -121,8 +123,8 @@ const isTooBig = (size, maxSize) => {
 };
 
 /**
- * @param {Record<string, number>} size size
- * @param {Record<string, number>} minSize minimum size
+ * @param {Sizes} size size
+ * @param {Sizes} minSize minimum size
  * @returns {boolean} true, when size is too small
  */
 const isTooSmall = (size, minSize) => {
@@ -136,8 +138,8 @@ const isTooSmall = (size, minSize) => {
 };
 
 /**
- * @param {Record<string, number>} size size
- * @param {Record<string, number>} minSize minimum size
+ * @param {Sizes} size size
+ * @param {Sizes} minSize minimum size
  * @returns {Set<string>} set of types that are too small
  */
 const getTooSmallTypes = (size, minSize) => {
@@ -166,7 +168,7 @@ const getNumberOfMatchingSizeTypes = (size, types) => {
 };
 
 /**
- * @param {Record<string, number>} size size
+ * @param {Sizes} size size
  * @param {Set<string>} types types
  * @returns {number} selective size sum
  */
@@ -185,7 +187,7 @@ class Node {
 	/**
 	 * @param {T} item item
 	 * @param {string} key key
-	 * @param {Record<string, number>} size size
+	 * @param {Sizes} size size
 	 */
 	constructor(item, key, size) {
 		this.item = item;
@@ -194,14 +196,16 @@ class Node {
 	}
 }
 
+/** @typedef {number[]} Similarities */
+
 /**
  * @template T
  */
 class Group {
 	/**
 	 * @param {Node<T>[]} nodes nodes
-	 * @param {number[] | null} similarities similarities between the nodes (length = nodes.length - 1)
-	 * @param {Record<string, number>=} size size of the group
+	 * @param {Similarities | null} similarities similarities between the nodes (length = nodes.length - 1)
+	 * @param {Sizes=} size size of the group
 	 */
 	constructor(nodes, similarities, size) {
 		this.nodes = nodes;
@@ -228,7 +232,7 @@ class Group {
 				if (newNodes.length > 0) {
 					newSimilarities.push(
 						lastNode === this.nodes[i - 1]
-							? /** @type {number[]} */ (this.similarities)[i - 1]
+							? /** @type {Similarities} */ (this.similarities)[i - 1]
 							: similarity(/** @type {Node<T>} */ (lastNode).key, node.key)
 					);
 				}
@@ -247,11 +251,11 @@ class Group {
 /**
  * @template T
  * @param {Iterable<Node<T>>} nodes nodes
- * @returns {number[]} similarities
+ * @returns {Similarities} similarities
  */
 const getSimilarities = (nodes) => {
 	// calculate similarities between lexically adjacent nodes
-	/** @type {number[]} */
+	/** @type {Similarities} */
 	const similarities = [];
 	let last;
 	for (const node of nodes) {
@@ -268,16 +272,16 @@ const getSimilarities = (nodes) => {
  * @typedef {object} GroupedItems<T>
  * @property {string} key
  * @property {T[]} items
- * @property {Record<string, number>} size
+ * @property {Sizes} size
  */
 
 /**
  * @template T
  * @typedef {object} Options
- * @property {Record<string, number>} maxSize maximum size of a group
- * @property {Record<string, number>} minSize minimum size of a group (preferred over maximum size)
+ * @property {Sizes} maxSize maximum size of a group
+ * @property {Sizes} minSize minimum size of a group (preferred over maximum size)
  * @property {Iterable<T>} items a list of items
- * @property {(item: T) => Record<string, number>} getSize function to get size of an item
+ * @property {(item: T) => Sizes} getSize function to get size of an item
  * @property {(item: T) => string} getKey function to get the key of an item
  */
 
@@ -320,7 +324,7 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 
 		/**
 		 * @param {Group<T>} group group
-		 * @param {Record<string, number>} consideredSize size of the group to consider
+		 * @param {Sizes} consideredSize size of the group to consider
 		 * @returns {boolean} true, if the group was modified
 		 */
 		const removeProblematicNodes = (group, consideredSize = group.size) => {
@@ -455,9 +459,9 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 					// rightSize ^^^^^^^^^^^^^^^
 
 					while (pos <= right + 1) {
-						const similarity = /** @type {number[]} */ (group.similarities)[
-							pos - 1
-						];
+						const similarity =
+							/** @type {Similarities} */
+							(group.similarities)[pos - 1];
 						if (
 							similarity < bestSimilarity &&
 							!isTooSmall(leftSize, minSize) &&
@@ -484,22 +488,22 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 				// create two new groups for left and right area
 				// and queue them up
 				const rightNodes = [group.nodes[right + 1]];
-				/** @type {number[]} */
+				/** @type {Similarities} */
 				const rightSimilarities = [];
 				for (let i = right + 2; i < group.nodes.length; i++) {
 					rightSimilarities.push(
-						/** @type {number[]} */ (group.similarities)[i - 1]
+						/** @type {Similarities} */ (group.similarities)[i - 1]
 					);
 					rightNodes.push(group.nodes[i]);
 				}
 				queue.push(new Group(rightNodes, rightSimilarities));
 
 				const leftNodes = [group.nodes[0]];
-				/** @type {number[]} */
+				/** @type {Similarities} */
 				const leftSimilarities = [];
 				for (let i = 1; i < left; i++) {
 					leftSimilarities.push(
-						/** @type {number[]} */ (group.similarities)[i - 1]
+						/** @type {Similarities} */ (group.similarities)[i - 1]
 					);
 					leftNodes.push(group.nodes[i]);
 				}