webpack 5.90.3 → 5.92.0

package/lib/stats/DefaultStatsFactoryPlugin.js

@@ -48,7 +48,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 
 /** @typedef {KnownStatsCompilation & Record<string, any>} StatsCompilation */
 /**
- * @typedef {Object} KnownStatsCompilation
+ * @typedef {object} KnownStatsCompilation
  * @property {any=} env
  * @property {string=} name
  * @property {string=} hash
@@ -76,7 +76,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 
 /** @typedef {KnownStatsLogging & Record<string, any>} StatsLogging */
 /**
- * @typedef {Object} KnownStatsLogging
+ * @typedef {object} KnownStatsLogging
  * @property {StatsLoggingEntry[]} entries
  * @property {number} filteredEntries
  * @property {boolean} debug
@@ -84,7 +84,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 
 /** @typedef {KnownStatsLoggingEntry & Record<string, any>} StatsLoggingEntry */
 /**
- * @typedef {Object} KnownStatsLoggingEntry
+ * @typedef {object} KnownStatsLoggingEntry
  * @property {string} type
  * @property {string} message
  * @property {string[]=} trace
@@ -95,7 +95,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 
 /** @typedef {KnownStatsAsset & Record<string, any>} StatsAsset */
 /**
- * @typedef {Object} KnownStatsAsset
+ * @typedef {object} KnownStatsAsset
  * @property {string} type
  * @property {string} name
  * @property {AssetInfo} info
@@ -116,7 +116,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 
 /** @typedef {KnownStatsChunkGroup & Record<string, any>} StatsChunkGroup */
 /**
- * @typedef {Object} KnownStatsChunkGroup
+ * @typedef {object} KnownStatsChunkGroup
  * @property {string=} name
  * @property {(string|number)[]=} chunks
  * @property {({ name: string, size?: number })[]=} assets
@@ -132,7 +132,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 
 /** @typedef {KnownStatsModule & Record<string, any>} StatsModule */
 /**
- * @typedef {Object} KnownStatsModule
+ * @typedef {object} KnownStatsModule
  * @property {string=} type
  * @property {string=} moduleType
  * @property {string=} layer
@@ -176,7 +176,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 
 /** @typedef {KnownStatsProfile & Record<string, any>} StatsProfile */
 /**
- * @typedef {Object} KnownStatsProfile
+ * @typedef {object} KnownStatsProfile
  * @property {number} total
  * @property {number} resolving
  * @property {number} restoring
@@ -191,7 +191,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 
 /** @typedef {KnownStatsModuleIssuer & Record<string, any>} StatsModuleIssuer */
 /**
- * @typedef {Object} KnownStatsModuleIssuer
+ * @typedef {object} KnownStatsModuleIssuer
  * @property {string=} identifier
  * @property {string=} name
  * @property {(string|number)=} id
@@ -200,7 +200,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 
 /** @typedef {KnownStatsModuleReason & Record<string, any>} StatsModuleReason */
 /**
- * @typedef {Object} KnownStatsModuleReason
+ * @typedef {object} KnownStatsModuleReason
  * @property {string=} moduleIdentifier
  * @property {string=} module
  * @property {string=} moduleName
@@ -217,7 +217,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 
 /** @typedef {KnownStatsChunk & Record<string, any>} StatsChunk */
 /**
- * @typedef {Object} KnownStatsChunk
+ * @typedef {object} KnownStatsChunk
  * @property {boolean} rendered
  * @property {boolean} initial
  * @property {boolean} entry
@@ -243,7 +243,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 
 /** @typedef {KnownStatsChunkOrigin & Record<string, any>} StatsChunkOrigin */
 /**
- * @typedef {Object} KnownStatsChunkOrigin
+ * @typedef {object} KnownStatsChunkOrigin
  * @property {string=} module
  * @property {string=} moduleIdentifier
  * @property {string=} moduleName
@@ -254,7 +254,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 
 /** @typedef {KnownStatsModuleTraceItem & Record<string, any>} StatsModuleTraceItem */
 /**
- * @typedef {Object} KnownStatsModuleTraceItem
+ * @typedef {object} KnownStatsModuleTraceItem
  * @property {string=} originIdentifier
  * @property {string=} originName
  * @property {string=} moduleIdentifier
@@ -266,13 +266,13 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
 
 /** @typedef {KnownStatsModuleTraceDependency & Record<string, any>} StatsModuleTraceDependency */
 /**
- * @typedef {Object} KnownStatsModuleTraceDependency
+ * @typedef {object} KnownStatsModuleTraceDependency
  * @property {string=} loc
  */
 
 /** @typedef {KnownStatsError & Record<string, any>} StatsError */
 /**
- * @typedef {Object} KnownStatsError
+ * @typedef {object} KnownStatsError
  * @property {string} message
  * @property {string=} chunkName
  * @property {boolean=} chunkEntry
@@ -297,7 +297,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  */
 
 /**
- * @typedef {Object} SimpleExtractors
+ * @typedef {object} SimpleExtractors
  * @property {ExtractorsByOption<Compilation, StatsCompilation>} compilation
  * @property {ExtractorsByOption<PreprocessedAsset, StatsAsset>} asset
  * @property {ExtractorsByOption<PreprocessedAsset, StatsAsset>} asset$visible
@@ -1526,7 +1526,7 @@ const FILTER = {
 	}
 };
 
-/** @type {Record<string, Record<string, (thing: Object, context: StatsFactoryContext, options: NormalizedStatsOptions) => boolean | undefined>>} */
+/** @type {Record<string, Record<string, (thing: object, context: StatsFactoryContext, options: NormalizedStatsOptions) => boolean | undefined>>} */
 const FILTER_RESULTS = {
 	"compilation.warnings": {
 		warningsFilter: util.deprecate(
@@ -2246,7 +2246,7 @@ const sortOrderRegular = field => {
 
 /**
  * @param {string} field field name
- * @returns {function(Object, Object): number} comparators
+ * @returns {function(object, object): number} comparators
  */
 const sortByField = field => {
 	if (!field) {
@@ -2361,8 +2361,8 @@ const ITEM_NAMES = {
 };
 
 /**
- * @param {Object[]} items items to be merged
- * @returns {Object} an object
+ * @param {object[]} items items to be merged
+ * @returns {object} an object
  */
 const mergeToObject = items => {
 	const obj = Object.create(null);
@@ -2372,7 +2372,7 @@ const mergeToObject = items => {
 	return obj;
 };
 
-/** @type {Record<string, (items: Object[]) => any>} */
+/** @type {Record<string, (items: object[]) => any>} */
 const MERGER = {
 	"compilation.entrypoints": mergeToObject,
 	"compilation.namedChunkGroups": mergeToObject

package/lib/stats/DefaultStatsPrinterPlugin.js

@@ -22,7 +22,7 @@ const plural = (n, singular, plural) => (n === 1 ? singular : plural);
 
 /**
  * @param {Record<string, number>} sizes sizes by source type
- * @param {Object} options options
+ * @param {object} options options
  * @param {(number) => string=} options.formatSize size formatter
  * @returns {string} text
  */

package/lib/stats/StatsFactory.js

@@ -18,7 +18,7 @@ const smartGrouping = require("../util/smartGrouping");
 /** @typedef {import("../util/smartGrouping").GroupConfig<any, object>} GroupConfig */
 
 /**
- * @typedef {Object} KnownStatsFactoryContext
+ * @typedef {object} KnownStatsFactoryContext
  * @property {string} type
  * @property {function(string): string=} makePathsRelative
  * @property {Compilation=} compilation
@@ -35,7 +35,7 @@ const smartGrouping = require("../util/smartGrouping");
 class StatsFactory {
 	constructor() {
 		this.hooks = Object.freeze({
-			/** @type {HookMap<SyncBailHook<[Object, any, StatsFactoryContext]>>} */
+			/** @type {HookMap<SyncBailHook<[object, any, StatsFactoryContext]>>} */
 			extract: new HookMap(
 				() => new SyncBailHook(["object", "data", "context"])
 			),

package/lib/stats/StatsPrinter.js

@@ -17,13 +17,13 @@ const { HookMap, SyncWaterfallHook, SyncBailHook } = require("tapable");
 /** @typedef {import("./DefaultStatsFactoryPlugin").StatsModuleReason} StatsModuleReason */
 
 /**
- * @typedef {Object} PrintedElement
+ * @typedef {object} PrintedElement
  * @property {string} element
  * @property {string} content
  */
 
 /**
- * @typedef {Object} KnownStatsPrinterContext
+ * @typedef {object} KnownStatsPrinterContext
  * @property {string=} type
  * @property {StatsCompilation=} compilation
  * @property {StatsChunkGroup=} chunkGroup
@@ -147,8 +147,8 @@ class StatsPrinter {
 
 	/**
 	 * @param {string} type The type
-	 * @param {Object} object Object to print
-	 * @param {Object=} baseContext The base context
+	 * @param {object} object Object to print
+	 * @param {object=} baseContext The base context
 	 * @returns {string} printed result
 	 */
 	print(type, object, baseContext) {
@@ -168,8 +168,8 @@ class StatsPrinter {
 	/**
 	 * @private
 	 * @param {string} type type
-	 * @param {Object} object object
-	 * @param {Object=} baseContext context
+	 * @param {object} object object
+	 * @param {object=} baseContext context
 	 * @returns {string} printed result
 	 */
 	_print(type, object, baseContext) {

package/lib/util/ArrayQueue.js

@@ -13,9 +13,15 @@ class ArrayQueue {
 	 * @param {Iterable<T>=} items The initial elements.
 	 */
 	constructor(items) {
-		/** @private @type {T[]} */
+		/**
+		 * @private
+		 * @type {T[]}
+		 */
 		this._list = items ? Array.from(items) : [];
-		/** @private @type {T[]} */
+		/**
+		 * @private
+		 * @type {T[]}
+		 */
 		this._listReversed = [];
 	}
 
@@ -77,31 +83,18 @@ class ArrayQueue {
 	}
 
 	[Symbol.iterator]() {
-		let i = -1;
-		let reversed = false;
 		return {
 			next: () => {
-				if (!reversed) {
-					i++;
-					if (i < this._list.length) {
-						return {
-							done: false,
-							value: this._list[i]
-						};
-					}
-					reversed = true;
-					i = this._listReversed.length;
-				}
-				i--;
-				if (i < 0) {
+				const item = this.dequeue();
+				if (item) {
 					return {
-						done: true,
-						value: undefined
+						done: false,
+						value: item
 					};
 				}
 				return {
-					done: false,
-					value: this._listReversed[i]
+					done: true,
+					value: undefined
 				};
 			}
 		};

package/lib/util/AsyncQueue.js

@@ -53,7 +53,7 @@ class AsyncQueueEntry {
  */
 class AsyncQueue {
 	/**
-	 * @param {Object} options options object
+	 * @param {object} options options object
 	 * @param {string=} options.name name of the queue
 	 * @param {number=} options.parallelism how many items should be processed at once
 	 * @param {AsyncQueue<any, any, any>=} options.parent parent queue, which will have priority over this queue and with shared parallelism

package/lib/util/Queue.js

@@ -13,9 +13,15 @@ class Queue {
 	 * @param {Iterable<T>=} items The initial elements.
 	 */
 	constructor(items) {
-		/** @private @type {Set<T>} */
+		/**
+		 * @private
+		 * @type {Set<T>}
+		 */
 		this._set = new Set(items);
-		/** @private @type {Iterator<T>} */
+		/**
+		 * @private
+		 * @type {Iterator<T>}
+		 */
 		this._iterator = this._set[Symbol.iterator]();
 	}
 

package/lib/util/SortableSet.js

@@ -21,13 +21,25 @@ class SortableSet extends Set {
 	 */
 	constructor(initialIterable, defaultSort) {
 		super(initialIterable);
-		/** @private @type {undefined | function(T, T): number}} */
+		/**
+		 * @private
+		 * @type {undefined | function(T, T): number}}
+		 */
 		this._sortFn = defaultSort;
-		/** @private @type {typeof NONE | undefined | function(T, T): number}} */
+		/**
+		 * @private
+		 * @type {typeof NONE | undefined | function(T, T): number}}
+		 */
 		this._lastActiveSortFn = NONE;
-		/** @private @type {Map<Function, any> | undefined} */
+		/**
+		 * @private
+		 * @type {Map<Function, any> | undefined}
+		 */
 		this._cache = undefined;
-		/** @private @type {Map<Function, any> | undefined} */
+		/**
+		 * @private
+		 * @type {Map<Function, any> | undefined}
+		 */
 		this._cacheOrderIndependent = undefined;
 	}
 

package/lib/util/StackedCacheMap.js

@@ -8,6 +8,29 @@
 /**
  * @template K
  * @template V
+ *
+ * The StackedCacheMap is a data structure designed as an alternative to a Map
+ * in situations where you need to handle multiple item additions and
+ * frequently access the largest map.
+ *
+ * It is particularly optimized for efficiently adding multiple items
+ * at once, which can be achieved using the `addAll` method.
+ *
+ * It has a fallback Map that is used when the map to be added is mutable.
+ *
+ * Note: `delete` and `has` are not supported for performance reasons.
+ *
+ * @example
+ * ```js
+ * const map = new StackedCacheMap();
+ * map.addAll(new Map([["a", 1], ["b", 2]]), true);
+ * map.addAll(new Map([["c", 3], ["d", 4]]), true);
+ * map.get("a"); // 1
+ * map.get("d"); // 4
+ * for (const [key, value] of map) {
+ * 		console.log(key, value);
+ * }
+ * ```
  */
 class StackedCacheMap {
 	constructor() {
@@ -18,6 +41,9 @@ class StackedCacheMap {
 	}
 
 	/**
+	 * If `immutable` is true, the map can be referenced by the StackedCacheMap
+	 * and should not be changed afterwards. If the map is mutable, all items
+	 * are copied into a fallback Map.
 	 * @param {ReadonlyMap<K, V>} map map to add
 	 * @param {boolean=} immutable if 'map' is immutable and StackedCacheMap can keep referencing it
 	 */

package/lib/util/TupleQueue.js

@@ -15,9 +15,15 @@ class TupleQueue {
 	 * @param {Iterable<T>=} items The initial elements.
 	 */
 	constructor(items) {
-		/** @private @type {TupleSet<T>} */
+		/**
+		 * @private
+		 * @type {TupleSet<T>}
+		 */
 		this._set = new TupleSet(items);
-		/** @private @type {Iterator<T>} */
+		/**
+		 * @private
+		 * @type {Iterator<T>}
+		 */
 		this._iterator = this._set[Symbol.iterator]();
 	}
 

package/lib/util/WeakTupleMap.js

@@ -5,6 +5,21 @@
 
 "use strict";
 
+/**
+ * @template {any[]} T
+ * @template V
+ * @typedef {Map<object, WeakTupleMap<T, V>>} M
+ */
+/**
+ * @template {any[]} T
+ * @template V
+ * @typedef {WeakMap<object, WeakTupleMap<T, V>>} W
+ */
+
+/**
+ * @param {any} thing thing
+ * @returns {boolean} true if is weak
+ */
 const isWeakKey = thing => typeof thing === "object" && thing !== null;
 
 /**
@@ -15,11 +30,20 @@ class WeakTupleMap {
 	constructor() {
 		/** @private */
 		this.f = 0;
-		/** @private @type {any} */
+		/**
+		 * @private
+		 * @type {any}
+		 */
 		this.v = undefined;
-		/** @private @type {Map<object, WeakTupleMap<T, V>> | undefined} */
+		/**
+		 * @private
+		 * @type {M<T, V> | undefined}
+		 */
 		this.m = undefined;
-		/** @private @type {WeakMap<object, WeakTupleMap<T, V>> | undefined} */
+		/**
+		 * @private
+		 * @type {W<T, V> | undefined}
+		 */
 		this.w = undefined;
 	}
 
@@ -41,7 +65,7 @@ class WeakTupleMap {
 	 * @returns {boolean} true, if the tuple is in the Set
 	 */
 	has(...args) {
-		/** @type {WeakTupleMap<T, V>} */
+		/** @type {WeakTupleMap<T, V> | undefined} */
 		let node = this;
 		for (let i = 0; i < args.length; i++) {
 			node = node._peek(args[i]);
@@ -52,10 +76,10 @@ class WeakTupleMap {
 
 	/**
 	 * @param {T} args tuple
-	 * @returns {V} the value
+	 * @returns {V | undefined} the value
 	 */
 	get(...args) {
-		/** @type {WeakTupleMap<T, V>} */
+		/** @type {WeakTupleMap<T, V> | undefined} */
 		let node = this;
 		for (let i = 0; i < args.length; i++) {
 			node = node._peek(args[i]);
@@ -86,7 +110,7 @@ class WeakTupleMap {
 	 * @returns {void}
 	 */
 	delete(...args) {
-		/** @type {WeakTupleMap<T, V>} */
+		/** @type {WeakTupleMap<T, V> | undefined} */
 		let node = this;
 		for (let i = 0; i < args.length; i++) {
 			node = node._peek(args[i]);
@@ -113,6 +137,10 @@ class WeakTupleMap {
 		return (this.f & 1) === 1;
 	}
 
+	/**
+	 * @param {any} v value
+	 * @private
+	 */
 	_setValue(v) {
 		this.f |= 1;
 		this.v = v;
@@ -123,16 +151,26 @@ class WeakTupleMap {
 		this.v = undefined;
 	}
 
+	/**
+	 * @param {any} thing thing
+	 * @returns {WeakTupleMap<T, V> | undefined} thing
+	 * @private
+	 */
 	_peek(thing) {
 		if (isWeakKey(thing)) {
 			if ((this.f & 4) !== 4) return undefined;
-			return this.w.get(thing);
+			return /** @type {W<T, V>} */ (this.w).get(thing);
 		} else {
 			if ((this.f & 2) !== 2) return undefined;
-			return this.m.get(thing);
+			return /** @type {M<T, V>} */ (this.m).get(thing);
 		}
 	}
 
+	/**
+	 * @private
+	 * @param {any} thing thing
+	 * @returns {WeakTupleMap<T, V>} value
+	 */
 	_get(thing) {
 		if (isWeakKey(thing)) {
 			if ((this.f & 4) !== 4) {
@@ -142,12 +180,15 @@ class WeakTupleMap {
 				(this.w = newMap).set(thing, newNode);
 				return newNode;
 			}
-			const entry = this.w.get(thing);
+			const entry =
+				/** @type {W<T, V>} */
+				(this.w).get(thing);
 			if (entry !== undefined) {
 				return entry;
 			}
 			const newNode = new WeakTupleMap();
-			this.w.set(thing, newNode);
+			/** @type {W<T, V>} */
+			(this.w).set(thing, newNode);
 			return newNode;
 		} else {
 			if ((this.f & 2) !== 2) {
@@ -157,12 +198,15 @@ class WeakTupleMap {
 				(this.m = newMap).set(thing, newNode);
 				return newNode;
 			}
-			const entry = this.m.get(thing);
+			const entry =
+				/** @type {M<T, V>} */
+				(this.m).get(thing);
 			if (entry !== undefined) {
 				return entry;
 			}
 			const newNode = new WeakTupleMap();
-			this.m.set(thing, newNode);
+			/** @type {M<T, V>} */
+			(this.m).set(thing, newNode);
 			return newNode;
 		}
 	}

package/lib/util/binarySearchBounds.js

@@ -75,7 +75,7 @@ const compileSearch = (funcName, predicate, reversed, extraArgs, earlyOut) => {
  * @param {boolean} reversed Whether the search should be reversed.
  * @param {SearchPredicateSuffix} suffix The suffix to be used in the function name.
  * @param {boolean=} earlyOut Whether the search should return as soon as a match is found.
- * @returns {function} The compiled binary search function.
+ * @returns {Function} The compiled binary search function.
  */
 const compileBoundsSearch = (predicate, reversed, suffix, earlyOut) => {
 	const arg1 = compileSearch(

package/lib/util/cleverMerge.js

@@ -38,11 +38,11 @@ const cachedCleverMerge = (first, second) => {
 		innerCache = new WeakMap();
 		mergeCache.set(first, innerCache);
 	}
-	const prevMerge = innerCache.get(second);
+	const prevMerge = /** @type {T & O} */ (innerCache.get(second));
 	if (prevMerge !== undefined) return prevMerge;
 	const newMerge = _cleverMerge(first, second, true);
 	innerCache.set(second, newMerge);
-	return newMerge;
+	return /** @type {T & O} */ (newMerge);
 };
 
 /**
@@ -69,7 +69,7 @@ const cachedSetProperty = (obj, property, value) => {
 
 	let result = mapByValue.get(value);
 
-	if (result) return result;
+	if (result) return /** @type {T} */ (result);
 
 	result = {
 		...obj,
@@ -77,18 +77,18 @@ const cachedSetProperty = (obj, property, value) => {
 	};
 	mapByValue.set(value, result);
 
-	return result;
+	return /** @type {T} */ (result);
 };
 
 /**
- * @typedef {Object} ObjectParsedPropertyEntry
+ * @typedef {object} ObjectParsedPropertyEntry
  * @property {any | undefined} base base value
  * @property {string | undefined} byProperty the name of the selector property
  * @property {Map<string, any>} byValues value depending on selector property, merged with base
  */
 
 /**
- * @typedef {Object} ParsedObject
+ * @typedef {object} ParsedObject
  * @property {Map<string, ObjectParsedPropertyEntry>} static static properties (key is property name)
  * @property {{ byProperty: string, fn: Function } | undefined} dynamic dynamic part
  */
@@ -257,7 +257,7 @@ const cleverMerge = (first, second) => {
 	if (typeof second !== "object" || second === null) return second;
 	if (typeof first !== "object" || first === null) return first;
 
-	return _cleverMerge(first, second, false);
+	return /** @type {T & O} */ (_cleverMerge(first, second, false));
 };
 
 /**
@@ -498,27 +498,40 @@ const mergeSingleValue = (a, b, internalCaching) => {
 };
 
 /**
- * @template T
+ * @template {object} T
  * @param {T} obj the object
+ * @param {(keyof T)[]=} keysToKeepOriginalValue keys to keep original value
  * @returns {T} the object without operations like "..." or DELETE
  */
-const removeOperations = obj => {
+const removeOperations = (obj, keysToKeepOriginalValue = []) => {
 	const newObj = /** @type {T} */ ({});
 	for (const key of Object.keys(obj)) {
-		const value = obj[key];
+		const value = obj[/** @type {keyof T} */ (key)];
 		const type = getValueType(value);
+		if (
+			type === VALUE_TYPE_OBJECT &&
+			keysToKeepOriginalValue.includes(/** @type {keyof T} */ (key))
+		) {
+			newObj[/** @type {keyof T} */ (key)] = value;
+			continue;
+		}
 		switch (type) {
 			case VALUE_TYPE_UNDEFINED:
 			case VALUE_TYPE_DELETE:
 				break;
 			case VALUE_TYPE_OBJECT:
-				newObj[key] = removeOperations(value);
+				newObj[key] = removeOperations(
+					/** @type {TODO} */ (value),
+					keysToKeepOriginalValue
+				);
 				break;
 			case VALUE_TYPE_ARRAY_EXTEND:
-				newObj[key] = value.filter(i => i !== "...");
+				newObj[key] =
+					/** @type {any[]} */
+					(value).filter(i => i !== "...");
 				break;
 			default:
-				newObj[key] = value;
+				newObj[/** @type {keyof T} */ (key)] = value;
 				break;
 		}
 	}