webpack 5.106.1 → 5.107.0

package/lib/url/URLParserPlugin.js

@@ -6,13 +6,13 @@
 "use strict";
 
 const { pathToFileURL } = require("url");
-const CommentCompilationWarning = require("../CommentCompilationWarning");
 const RuntimeGlobals = require("../RuntimeGlobals");
-const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
 const ConstDependency = require("../dependencies/ConstDependency");
 const ContextDependencyHelpers = require("../dependencies/ContextDependencyHelpers");
 const URLContextDependency = require("../dependencies/URLContextDependency");
 const URLDependency = require("../dependencies/URLDependency");
+const CommentCompilationWarning = require("../errors/CommentCompilationWarning");
+const UnsupportedFeatureWarning = require("../errors/UnsupportedFeatureWarning");
 const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
 const { approve } = require("../javascript/JavascriptParserHelpers");
 const InnerGraph = require("../optimize/InnerGraph");
@@ -28,12 +28,14 @@ const InnerGraph = require("../optimize/InnerGraph");
 const PLUGIN_NAME = "URLParserPlugin";
 
 /**
+ * Returns file url.
  * @param {NormalModule} module module
  * @returns {URL} file url
  */
 const getUrl = (module) => pathToFileURL(module.resource);
 
 /**
+ * Checks whether this object is meta url.
  * @param {JavascriptParser} parser parser parser
  * @param {MemberExpression} arg arg
  * @returns {boolean} true when it is `meta.url`, otherwise false
@@ -58,6 +60,7 @@ const isMetaUrl = (parser, arg) => {
 const getEvaluatedExprCache = new WeakMap();
 
 /**
+ * Gets evaluated expr.
  * @param {NewExpressionNode} expr expression
  * @param {JavascriptParser} parser parser parser
  * @returns {BasicEvaluatedExpression | undefined} basic evaluated expression
@@ -67,6 +70,7 @@ const getEvaluatedExpr = (expr, parser) => {
 	if (result !== undefined) return result;
 
 	/**
+	 * Returns basic evaluated expression.
 	 * @returns {BasicEvaluatedExpression | undefined} basic evaluated expression
 	 */
 	const evaluate = () => {
@@ -90,6 +94,7 @@ const getEvaluatedExpr = (expr, parser) => {
 
 class URLParserPlugin {
 	/**
+	 * Creates an instance of URLParserPlugin.
 	 * @param {JavascriptParserOptions} options options
 	 */
 	constructor(options) {
@@ -98,6 +103,7 @@ class URLParserPlugin {
 	}
 
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {JavascriptParser} parser the parser
 	 * @returns {void}
 	 */

package/lib/util/AppendOnlyStackedSet.js

@@ -6,10 +6,14 @@
 "use strict";
 
 /**
+ * Tracks values across a stack of nested sets where child scopes can add new
+ * values without mutating the sets created by their parents.
  * @template T
  */
 class AppendOnlyStackedSet {
 	/**
+	 * Seeds the stacked set with an optional chain of previously created scope
+	 * layers.
 	 * @param {Set<T>[]} sets an optional array of sets
 	 */
 	constructor(sets = []) {
@@ -20,6 +24,8 @@ class AppendOnlyStackedSet {
 	}
 
 	/**
+	 * Adds a value to the current scope layer, creating that layer lazily when
+	 * the first write occurs.
 	 * @param {T} el element
 	 */
 	add(el) {
@@ -31,6 +37,8 @@ class AppendOnlyStackedSet {
 	}
 
 	/**
+	 * Checks whether a value is present in any scope layer currently visible to
+	 * this stacked set.
 	 * @param {T} el element
 	 * @returns {boolean} result
 	 */
@@ -41,6 +49,9 @@ class AppendOnlyStackedSet {
 		return false;
 	}
 
+	/**
+	 * Removes every scope layer and any values accumulated in them.
+	 */
 	clear() {
 		this._sets = [];
 		if (this._current) {
@@ -49,6 +60,8 @@ class AppendOnlyStackedSet {
 	}
 
 	/**
+	 * Creates a child stacked set that shares the existing scope history while
+	 * allowing subsequent additions to be recorded in its own new layer.
 	 * @returns {AppendOnlyStackedSet<T>} child
 	 */
 	createChild() {
@@ -56,6 +69,8 @@ class AppendOnlyStackedSet {
 	}
 
 	/**
+	 * Iterates over the stacked sets from newest to oldest so consumers can
+	 * inspect recently added values first.
 	 * @returns {Iterator<T>} iterable iterator
 	 */
 	[Symbol.iterator]() {

package/lib/util/ArrayHelpers.js

@@ -34,6 +34,7 @@ module.exports.groupBy = (
 ) =>
 	arr.reduce(
 		/**
+		 * Handles the callback logic for this hook.
 		 * @param {[T[], T[]]} groups An accumulator storing already partitioned values returned from previous call.
 		 * @param {T} value The value of the current element
 		 * @returns {[T[], T[]]} returns an array of partitioned groups accumulator resulting from calling a predicate on the current value.

package/lib/util/ArrayQueue.js

@@ -6,10 +6,13 @@
 "use strict";
 
 /**
+ * FIFO queue backed by arrays with a reversed dequeue buffer to avoid the cost
+ * of repeated `Array#shift` operations.
  * @template T
  */
 class ArrayQueue {
 	/**
+	 * Seeds the queue with an optional iterable of items in dequeue order.
 	 * @param {Iterable<T>=} items The initial elements.
 	 */
 	constructor(items) {
@@ -26,7 +29,7 @@ class ArrayQueue {
 	}
 
 	/**
-	 * Returns the number of elements in this queue.
+	 * Returns the current number of items waiting in either internal buffer.
 	 * @returns {number} The number of elements in this queue.
 	 */
 	get length() {
@@ -34,7 +37,7 @@ class ArrayQueue {
 	}
 
 	/**
-	 * Empties the queue.
+	 * Removes all pending items from both internal buffers.
 	 */
 	clear() {
 		this._list.length = 0;
@@ -42,7 +45,7 @@ class ArrayQueue {
 	}
 
 	/**
-	 * Appends the specified element to this queue.
+	 * Appends an item to the tail of the queue.
 	 * @param {T} item The element to add.
 	 * @returns {void}
 	 */
@@ -51,7 +54,8 @@ class ArrayQueue {
 	}
 
 	/**
-	 * Retrieves and removes the head of this queue.
+	 * Removes and returns the next item in FIFO order, switching to a reversed
+	 * buffer when that is cheaper than shifting from the front of the array.
 	 * @returns {T | undefined} The head of the queue of `undefined` if this queue is empty.
 	 */
 	dequeue() {
@@ -68,7 +72,8 @@ class ArrayQueue {
 	}
 
 	/**
-	 * Finds and removes an item
+	 * Removes the first matching item from whichever internal buffer currently
+	 * contains it.
 	 * @param {T} item the item
 	 * @returns {void}
 	 */

package/lib/util/AsyncQueue.js

@@ -6,8 +6,8 @@
 "use strict";
 
 const { AsyncSeriesHook, SyncHook } = require("tapable");
-const { makeWebpackError } = require("../HookWebpackError");
-const WebpackError = require("../WebpackError");
+const { makeWebpackError } = require("../errors/HookWebpackError");
+const WebpackError = require("../errors/WebpackError");
 const ArrayQueue = require("./ArrayQueue");
 
 const QUEUED_STATE = 0;
@@ -17,6 +17,7 @@ const DONE_STATE = 2;
 let inHandleResult = 0;
 
 /**
+ * Defines the callback callback.
  * @template T
  * @callback Callback
  * @param {(WebpackError | null)=} err
@@ -25,12 +26,14 @@ let inHandleResult = 0;
  */
 
 /**
+ * Represents AsyncQueueEntry.
  * @template T
  * @template K
  * @template R
  */
 class AsyncQueueEntry {
 	/**
+	 * Creates an instance of AsyncQueueEntry.
 	 * @param {T} item the item
 	 * @param {Callback<R>} callback the callback
 	 */
@@ -50,22 +53,26 @@ class AsyncQueueEntry {
 }
 
 /**
+ * Defines the get key type used by this module.
  * @template T, K
  * @typedef {(item: T) => K} getKey
  */
 
 /**
+ * Defines the processor type used by this module.
  * @template T, R
  * @typedef {(item: T, callback: Callback<R>) => void} Processor
  */
 
 /**
+ * Represents AsyncQueue.
  * @template T
  * @template K
  * @template R
  */
 class AsyncQueue {
 	/**
+	 * Creates an instance of AsyncQueue.
 	 * @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
@@ -119,6 +126,7 @@ class AsyncQueue {
 	}
 
 	/**
+	 * Returns context of execution.
 	 * @returns {string} context of execution
 	 */
 	getContext() {
@@ -126,6 +134,7 @@ class AsyncQueue {
 	}
 
 	/**
+	 * Updates context using the provided value.
 	 * @param {string} value context of execution
 	 */
 	setContext(value) {
@@ -133,6 +142,7 @@ class AsyncQueue {
 	}
 
 	/**
+	 * Processes the provided item.
 	 * @param {T} item an item
 	 * @param {Callback<R>} callback callback function
 	 * @returns {void}
@@ -185,6 +195,7 @@ class AsyncQueue {
 	}
 
 	/**
+	 * Processes the provided item.
 	 * @param {T} item an item
 	 * @returns {void}
 	 */
@@ -225,6 +236,7 @@ class AsyncQueue {
 	}
 
 	/**
+	 * Describes how this stop operation behaves.
 	 * @returns {void}
 	 */
 	stop() {
@@ -245,6 +257,7 @@ class AsyncQueue {
 	}
 
 	/**
+	 * Increase parallelism.
 	 * @returns {void}
 	 */
 	increaseParallelism() {
@@ -258,6 +271,7 @@ class AsyncQueue {
 	}
 
 	/**
+	 * Decrease parallelism.
 	 * @returns {void}
 	 */
 	decreaseParallelism() {
@@ -266,6 +280,7 @@ class AsyncQueue {
 	}
 
 	/**
+	 * Checks whether this async queue is processing.
 	 * @param {T} item an item
 	 * @returns {boolean} true, if the item is currently being processed
 	 */
@@ -276,6 +291,7 @@ class AsyncQueue {
 	}
 
 	/**
+	 * Checks whether this async queue is queued.
 	 * @param {T} item an item
 	 * @returns {boolean} true, if the item is currently queued
 	 */
@@ -286,6 +302,7 @@ class AsyncQueue {
 	}
 
 	/**
+	 * Checks whether this async queue is done.
 	 * @param {T} item an item
 	 * @returns {boolean} true, if the item is currently queued
 	 */
@@ -296,6 +313,7 @@ class AsyncQueue {
 	}
 
 	/**
+	 * Describes how this ensure processing operation behaves.
 	 * @returns {void}
 	 */
 	_ensureProcessing() {
@@ -324,6 +342,7 @@ class AsyncQueue {
 	}
 
 	/**
+	 * Processes the provided entry.
 	 * @param {AsyncQueueEntry<T, K, R>} entry the entry
 	 * @returns {void}
 	 */
@@ -351,6 +370,7 @@ class AsyncQueue {
 	}
 
 	/**
+	 * Processes the provided entry.
 	 * @param {AsyncQueueEntry<T, K, R>} entry the entry
 	 * @param {(WebpackError | null)=} err error, if any
 	 * @param {(R | null)=} result result, if any

package/lib/util/Hash.js

@@ -33,7 +33,7 @@ class Hash {
 	 * @returns {Hash} updated hash
 	 */
 	update(data, inputEncoding) {
-		const AbstractMethodError = require("../AbstractMethodError");
+		const AbstractMethodError = require("../errors/AbstractMethodError");
 
 		throw new AbstractMethodError();
 	}
@@ -59,7 +59,7 @@ class Hash {
 	 * @returns {string | Buffer} digest
 	 */
 	digest(encoding) {
-		const AbstractMethodError = require("../AbstractMethodError");
+		const AbstractMethodError = require("../errors/AbstractMethodError");
 
 		throw new AbstractMethodError();
 	}

package/lib/util/IterableHelpers.js

@@ -6,6 +6,7 @@
 "use strict";
 
 /**
+ * Returns last item.
  * @template T
  * @param {Iterable<T>} set a set
  * @returns {T | undefined} last item
@@ -18,6 +19,7 @@ const last = (set) => {
 };
 
 /**
+ * Returns true, if some items match the filter predicate.
  * @template T
  * @param {Iterable<T>} iterable iterable
  * @param {(value: T) => boolean | null | undefined} filter predicate
@@ -31,6 +33,7 @@ const someInIterable = (iterable, filter) => {
 };
 
 /**
+ * Returns count of items.
  * @template T
  * @param {Iterable<T>} iterable an iterable
  * @returns {number} count of items

package/lib/util/LazyBucketSortedSet.js

@@ -9,23 +9,28 @@ const { first } = require("./SetHelpers");
 const SortableSet = require("./SortableSet");
 
 /**
+ * Callback that extracts the grouping key for an item at one bucket layer.
  * @template T
  * @template K
  * @typedef {(item: T) => K} GetKey
  */
 
 /**
+ * Comparison function used to order keys or leaf items.
  * @template T
  * @typedef {(a: T, n: T) => number} Comparator
  */
 
 /**
+ * Internal bucket entry, either another nested bucket set or a sorted leaf set.
  * @template T
  * @template K
  * @typedef {LazyBucketSortedSet<T, K> | SortableSet<T>} Entry
  */
 
 /**
+ * Constructor argument accepted for nested bucket layers or the final leaf
+ * comparator.
  * @template T
  * @template K
  * @typedef {GetKey<T, K> | Comparator<K> | Comparator<T>} Arg
@@ -45,6 +50,8 @@ const SortableSet = require("./SortableSet");
  */
 class LazyBucketSortedSet {
 	/**
+	 * Creates a lazily sorted, potentially multi-level bucket structure whose
+	 * order is only fully resolved when items are popped.
 	 * @param {GetKey<T, K>} getKey function to get key from item
 	 * @param {Comparator<K>=} comparator comparator to sort keys
 	 * @param {...Arg<T, K>} args more pairs of getKey and comparator plus optional final comparator for the last layer
@@ -62,6 +69,8 @@ class LazyBucketSortedSet {
 	}
 
 	/**
+	 * Adds an item to the unsorted staging area so sorting can be deferred until
+	 * an ordered pop is requested.
 	 * @param {T} item an item
 	 * @returns {void}
 	 */
@@ -71,6 +80,8 @@ class LazyBucketSortedSet {
 	}
 
 	/**
+	 * Inserts an item into the correct nested bucket, creating intermediate
+	 * bucket structures on demand.
 	 * @param {K} key key of item
 	 * @param {T} item the item
 	 * @returns {void}
@@ -95,6 +106,8 @@ class LazyBucketSortedSet {
 	}
 
 	/**
+	 * Removes an item from either the unsorted staging area or its resolved
+	 * bucket and prunes empty buckets as needed.
 	 * @param {T} item an item
 	 * @returns {void}
 	 */
@@ -113,6 +126,7 @@ class LazyBucketSortedSet {
 	}
 
 	/**
+	 * Removes an empty bucket key and its corresponding nested entry.
 	 * @param {K} key key to be removed
 	 * @returns {void}
 	 */
@@ -122,6 +136,8 @@ class LazyBucketSortedSet {
 	}
 
 	/**
+	 * Removes and returns the smallest item according to the configured bucket
+	 * order, sorting only the portions of the structure that are needed.
 	 * @returns {T | undefined} an item
 	 */
 	popFirst() {
@@ -158,6 +174,8 @@ class LazyBucketSortedSet {
 	}
 
 	/**
+	 * Begins an in-place update for an item and returns a completion callback
+	 * that can either reinsert it under a new key or remove it entirely.
 	 * @param {T} item to be updated item
 	 * @returns {(remove?: true) => void} finish update
 	 */
@@ -222,6 +240,8 @@ class LazyBucketSortedSet {
 	}
 
 	/**
+	 * Appends iterators for every stored bucket and leaf to support unordered
+	 * traversal across the entire structure.
 	 * @param {Iterator<T>[]} iterators list of iterators to append to
 	 * @returns {void}
 	 */
@@ -245,6 +265,7 @@ class LazyBucketSortedSet {
 	}
 
 	/**
+	 * Iterates over all stored items without imposing bucket sort order.
 	 * @returns {Iterator<T>} the iterator
 	 */
 	[Symbol.iterator]() {

package/lib/util/LazySet.js

@@ -8,6 +8,7 @@
 const makeSerializable = require("./makeSerializable");
 
 /**
+ * Merges every queued iterable directly into the concrete backing set.
  * @template T
  * @param {Set<T>} targetSet set where items should be added
  * @param {Set<Iterable<T>>} toMerge iterables to be merged
@@ -22,6 +23,8 @@ const merge = (targetSet, toMerge) => {
 };
 
 /**
+ * Flattens nested `LazySet` instances into a single collection of iterables
+ * that can later be merged into the backing set.
  * @template T
  * @param {Set<Iterable<T>>} targetSet set where iterables should be added
  * @param {LazySet<T>[]} toDeepMerge lazy sets to be flattened
@@ -40,6 +43,7 @@ const flatten = (targetSet, toDeepMerge) => {
 };
 
 /**
+ * Defines the set iterator type used by this module.
  * @template T
  * @typedef {import("typescript-iterable").SetIterator<T>} SetIterator
  */
@@ -52,6 +56,8 @@ const flatten = (targetSet, toDeepMerge) => {
  */
 class LazySet {
 	/**
+	 * Seeds the set with an optional iterable while preparing internal queues for
+	 * deferred merges.
 	 * @param {Iterable<T>=} iterable init iterable
 	 */
 	constructor(iterable) {
@@ -65,11 +71,17 @@ class LazySet {
 		this._deopt = false;
 	}
 
+	/**
+	 * Flattens any nested lazy sets that were queued for merging.
+	 */
 	_flatten() {
 		flatten(this._toMerge, this._toDeepMerge);
 		this._toDeepMerge.length = 0;
 	}
 
+	/**
+	 * Materializes all deferred additions into the backing set.
+	 */
 	_merge() {
 		this._flatten();
 		merge(this._set, this._toMerge);
@@ -77,6 +89,10 @@ class LazySet {
 		this._needMerge = false;
 	}
 
+	/**
+	 * Reports whether the set is empty without forcing a full merge.
+	 * @returns {boolean} true when no items have been stored or queued
+	 */
 	_isEmpty() {
 		return (
 			this._set.size === 0 &&
@@ -85,12 +101,17 @@ class LazySet {
 		);
 	}
 
+	/**
+	 * Returns the number of items after applying any deferred merges.
+	 * @returns {number} number of items in the set
+	 */
 	get size() {
 		if (this._needMerge) this._merge();
 		return this._set.size;
 	}
 
 	/**
+	 * Adds a single item immediately to the concrete backing set.
 	 * @param {T} item an item
 	 * @returns {LazySet<T>} itself
 	 */
@@ -100,6 +121,8 @@ class LazySet {
 	}
 
 	/**
+	 * Queues another iterable or lazy set for later merging so large bulk adds
+	 * can stay cheap until the set is read.
 	 * @param {Iterable<T> | LazySet<T>} iterable a immutable iterable or another immutable LazySet which will eventually be merged into the Set
 	 * @returns {LazySet<T>} itself
 	 */
@@ -126,6 +149,9 @@ class LazySet {
 		return this;
 	}
 
+	/**
+	 * Removes all items and clears every deferred merge queue.
+	 */
 	clear() {
 		this._set.clear();
 		this._toMerge.clear();
@@ -135,6 +161,8 @@ class LazySet {
 	}
 
 	/**
+	 * Deletes an item after first materializing any deferred additions that may
+	 * contain it.
 	 * @param {T} value an item
 	 * @returns {boolean} true, if the value was in the Set before
 	 */
@@ -144,6 +172,8 @@ class LazySet {
 	}
 
 	/**
+	 * Returns the set's entry iterator and permanently switches future
+	 * operations to eager merge mode to preserve iterator correctness.
 	 * @returns {SetIterator<[T, T]>} entries
 	 */
 	entries() {
@@ -153,6 +183,8 @@ class LazySet {
 	}
 
 	/**
+	 * Iterates over every item after forcing pending merges and switching to
+	 * eager mode for correctness during iteration.
 	 * @template K
 	 * @param {(value: T, value2: T, set: Set<T>) => void} callbackFn function called for each entry
 	 * @param {K} thisArg this argument for the callbackFn
@@ -166,6 +198,7 @@ class LazySet {
 	}
 
 	/**
+	 * Checks whether an item is present after applying any deferred merges.
 	 * @param {T} item an item
 	 * @returns {boolean} true, when the item is in the Set
 	 */
@@ -175,6 +208,7 @@ class LazySet {
 	}
 
 	/**
+	 * Returns the key iterator, eagerly materializing pending merges first.
 	 * @returns {SetIterator<T>} keys
 	 */
 	keys() {
@@ -184,6 +218,7 @@ class LazySet {
 	}
 
 	/**
+	 * Returns the value iterator, eagerly materializing pending merges first.
 	 * @returns {SetIterator<T>} values
 	 */
 	values() {
@@ -193,6 +228,7 @@ class LazySet {
 	}
 
 	/**
+	 * Returns the default iterator over values after forcing pending merges.
 	 * @returns {SetIterator<T>} iterable iterator
 	 */
 	[Symbol.iterator]() {
@@ -207,6 +243,8 @@ class LazySet {
 	}
 
 	/**
+	 * Serializes the fully materialized set contents into webpack's object
+	 * serialization stream.
 	 * @param {import("../serialization/ObjectMiddleware").ObjectSerializerContext} context context
 	 */
 	serialize({ write }) {
@@ -216,6 +254,7 @@ class LazySet {
 	}
 
 	/**
+	 * Restores a `LazySet` from serialized item data.
 	 * @template T
 	 * @param {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} context context
 	 * @returns {LazySet<T>} lazy set