webpack 5.97.1 → 5.104.1

package/lib/url/URLParserPlugin.js

@@ -0,0 +1,264 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Haijie Xie @hai-x
+*/
+
+"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 BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
+const { approve } = require("../javascript/JavascriptParserHelpers");
+const InnerGraph = require("../optimize/InnerGraph");
+
+/** @typedef {import("estree").MemberExpression} MemberExpression */
+/** @typedef {import("estree").NewExpression} NewExpressionNode */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
+const PLUGIN_NAME = "URLParserPlugin";
+
+/**
+ * @param {NormalModule} module module
+ * @returns {URL} file url
+ */
+const getUrl = (module) => pathToFileURL(module.resource);
+
+/**
+ * @param {JavascriptParser} parser parser parser
+ * @param {MemberExpression} arg arg
+ * @returns {boolean} true when it is `meta.url`, otherwise false
+ */
+const isMetaUrl = (parser, arg) => {
+	const chain = parser.extractMemberExpressionChain(arg);
+
+	if (
+		chain.members.length !== 1 ||
+		chain.object.type !== "MetaProperty" ||
+		chain.object.meta.name !== "import" ||
+		chain.object.property.name !== "meta" ||
+		chain.members[0] !== "url"
+	) {
+		return false;
+	}
+
+	return true;
+};
+
+/**
+ * @type {WeakMap<NewExpressionNode, BasicEvaluatedExpression | undefined>}
+ */
+const getEvaluatedExprCache = new WeakMap();
+
+/**
+ * @param {NewExpressionNode} expr expression
+ * @param {JavascriptParser} parser parser parser
+ * @returns {BasicEvaluatedExpression | undefined} basic evaluated expression
+ */
+const getEvaluatedExpr = (expr, parser) => {
+	let result = getEvaluatedExprCache.get(expr);
+	if (result !== undefined) return result;
+
+	/**
+	 * @returns {BasicEvaluatedExpression | undefined} basic evaluated expression
+	 */
+	const evaluate = () => {
+		if (expr.arguments.length !== 2) return;
+
+		const [arg1, arg2] = expr.arguments;
+
+		if (arg2.type !== "MemberExpression" || arg1.type === "SpreadElement") {
+			return;
+		}
+		if (!isMetaUrl(parser, arg2)) return;
+
+		return parser.evaluateExpression(arg1);
+	};
+
+	result = evaluate();
+	getEvaluatedExprCache.set(expr, result);
+
+	return result;
+};
+
+class URLParserPlugin {
+	/**
+	 * @param {JavascriptParserOptions} options options
+	 */
+	constructor(options) {
+		this.options = options;
+	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @returns {void}
+	 */
+	apply(parser) {
+		const relative = this.options.url === "relative";
+
+		parser.hooks.canRename.for("URL").tap(PLUGIN_NAME, approve);
+		parser.hooks.evaluateNewExpression.for("URL").tap(PLUGIN_NAME, (expr) => {
+			const evaluatedExpr = getEvaluatedExpr(expr, parser);
+			const request = evaluatedExpr && evaluatedExpr.asString();
+
+			if (!request) return;
+			const url = new URL(request, getUrl(parser.state.module));
+
+			return new BasicEvaluatedExpression()
+				.setString(url.toString())
+				.setRange(/** @type {Range} */ (expr.range));
+		});
+		parser.hooks.new.for("URL").tap(PLUGIN_NAME, (_expr) => {
+			const expr = /** @type {NewExpressionNode} */ (_expr);
+			const { options: importOptions, errors: commentErrors } =
+				parser.parseCommentOptions(/** @type {Range} */ (expr.range));
+
+			if (commentErrors) {
+				for (const e of commentErrors) {
+					const { comment } = e;
+					parser.state.module.addWarning(
+						new CommentCompilationWarning(
+							`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
+							/** @type {DependencyLocation} */ (comment.loc)
+						)
+					);
+				}
+			}
+
+			if (importOptions && importOptions.webpackIgnore !== undefined) {
+				if (typeof importOptions.webpackIgnore !== "boolean") {
+					parser.state.module.addWarning(
+						new UnsupportedFeatureWarning(
+							`\`webpackIgnore\` expected a boolean, but received: ${importOptions.webpackIgnore}.`,
+							/** @type {DependencyLocation} */ (expr.loc)
+						)
+					);
+					return;
+				} else if (importOptions.webpackIgnore) {
+					if (expr.arguments.length !== 2) return;
+
+					const [, arg2] = expr.arguments;
+
+					if (arg2.type !== "MemberExpression" || !isMetaUrl(parser, arg2)) {
+						return;
+					}
+
+					const dep = new ConstDependency(
+						RuntimeGlobals.baseURI,
+						/** @type {Range} */ (arg2.range),
+						[RuntimeGlobals.baseURI]
+					);
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					parser.state.module.addPresentationalDependency(dep);
+
+					return true;
+				}
+			}
+
+			const evaluatedExpr = getEvaluatedExpr(expr, parser);
+			if (!evaluatedExpr) return;
+
+			let request;
+
+			// static URL
+			if ((request = evaluatedExpr.asString())) {
+				const [arg1, arg2] = expr.arguments;
+				const dep = new URLDependency(
+					request,
+					[
+						/** @type {Range} */ (arg1.range)[0],
+						/** @type {Range} */ (arg2.range)[1]
+					],
+					/** @type {Range} */ (expr.range),
+					relative
+				);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				parser.state.current.addDependency(dep);
+				InnerGraph.onUsage(parser.state, (e) => (dep.usedByExports = e));
+				return true;
+			}
+
+			if (this.options.dynamicUrl === false) return;
+
+			// context URL
+			let include;
+			let exclude;
+
+			if (importOptions) {
+				if (importOptions.webpackInclude !== undefined) {
+					if (
+						!importOptions.webpackInclude ||
+						!(importOptions.webpackInclude instanceof RegExp)
+					) {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackInclude\` expected a regular expression, but received: ${importOptions.webpackInclude}.`,
+								/** @type {DependencyLocation} */ (expr.loc)
+							)
+						);
+					} else {
+						include = importOptions.webpackInclude;
+					}
+				}
+				if (importOptions.webpackExclude !== undefined) {
+					if (
+						!importOptions.webpackExclude ||
+						!(importOptions.webpackExclude instanceof RegExp)
+					) {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackExclude\` expected a regular expression, but received: ${importOptions.webpackExclude}.`,
+								/** @type {DependencyLocation} */ (expr.loc)
+							)
+						);
+					} else {
+						exclude = importOptions.webpackExclude;
+					}
+				}
+			}
+			const dep = ContextDependencyHelpers.create(
+				URLContextDependency,
+				/** @type {Range} */ (expr.range),
+				evaluatedExpr,
+				expr,
+				this.options,
+				{
+					include,
+					exclude,
+					mode: "sync",
+					typePrefix: "new URL with import.meta.url",
+					category: "url"
+				},
+				parser
+			);
+			if (!dep) return;
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			dep.optional = Boolean(parser.scope.inTry);
+			parser.state.current.addDependency(dep);
+			return true;
+		});
+		parser.hooks.isPure.for("NewExpression").tap(PLUGIN_NAME, (_expr) => {
+			const expr = /** @type {NewExpressionNode} */ (_expr);
+			const { callee } = expr;
+			if (callee.type !== "Identifier") return;
+			const calleeInfo = parser.getFreeInfoFromVariable(callee.name);
+			if (!calleeInfo || calleeInfo.name !== "URL") return;
+
+			const evaluatedExpr = getEvaluatedExpr(expr, parser);
+			const request = evaluatedExpr && evaluatedExpr.asString();
+
+			if (request) return true;
+		});
+	}
+}
+
+module.exports = URLParserPlugin;

package/lib/util/ArrayHelpers.js

@@ -7,12 +7,11 @@
 
 /**
  * Compare two arrays or strings by performing strict equality check for each value.
- * @template T [T=any]
+ * @template T
  * @param {ArrayLike<T>} a Array of values to be compared
  * @param {ArrayLike<T>} b Array of values to be compared
  * @returns {boolean} returns true if all the elements of passed arrays are strictly equal.
  */
-
 module.exports.equals = (a, b) => {
 	if (a.length !== b.length) return false;
 	for (let i = 0; i < a.length; i++) {
@@ -23,12 +22,11 @@ module.exports.equals = (a, b) => {
 
 /**
  * Partition an array by calling a predicate function on each value.
- * @template T [T=any]
- * @param {Array<T>} arr Array of values to be partitioned
+ * @template T
+ * @param {T[]} arr Array of values to be partitioned
  * @param {(value: T) => boolean} fn Partition function which partitions based on truthiness of result.
- * @returns {[Array<T>, Array<T>]} returns the values of `arr` partitioned into two new arrays based on fn predicate.
+ * @returns {[T[], T[]]} returns the values of `arr` partitioned into two new arrays based on fn predicate.
  */
-
 module.exports.groupBy = (
 	// eslint-disable-next-line default-param-last
 	arr = [],
@@ -36,9 +34,9 @@ module.exports.groupBy = (
 ) =>
 	arr.reduce(
 		/**
-		 * @param {[Array<T>, Array<T>]} groups An accumulator storing already partitioned values returned from previous call.
+		 * @param {[T[], T[]]} groups An accumulator storing already partitioned values returned from previous call.
 		 * @param {T} value The value of the current element
-		 * @returns {[Array<T>, Array<T>]} returns an array of partitioned groups accumulator resulting from calling a predicate on the current value.
+		 * @returns {[T[], T[]]} returns an array of partitioned groups accumulator resulting from calling a predicate on the current value.
 		 */
 		(groups, value) => {
 			groups[fn(value) ? 0 : 1].push(value);

package/lib/util/ArrayQueue.js

@@ -17,7 +17,7 @@ class ArrayQueue {
 		 * @private
 		 * @type {T[]}
 		 */
-		this._list = items ? Array.from(items) : [];
+		this._list = items ? [...items] : [];
 		/**
 		 * @private
 		 * @type {T[]}

package/lib/util/AsyncQueue.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const { SyncHook, AsyncSeriesHook } = require("tapable");
+const { AsyncSeriesHook, SyncHook } = require("tapable");
 const { makeWebpackError } = require("../HookWebpackError");
 const WebpackError = require("../WebpackError");
 const ArrayQueue = require("./ArrayQueue");
@@ -21,6 +21,7 @@ let inHandleResult = 0;
  * @callback Callback
  * @param {(WebpackError | null)=} err
  * @param {(T | null)=} result
+ * @returns {void}
  */
 
 /**
@@ -50,12 +51,12 @@ class AsyncQueueEntry {
 
 /**
  * @template T, K
- * @typedef {function(T): K} getKey
+ * @typedef {(item: T) => K} getKey
  */
 
 /**
  * @template T, R
- * @typedef {function(T, Callback<R>): void} Processor
+ * @typedef {(item: T, callback: Callback<R>) => void} Processor
  */
 
 /**
@@ -69,7 +70,7 @@ class AsyncQueue {
 	 * @param {string=} options.name name of the queue
 	 * @param {number=} options.parallelism how many items should be processed at once
 	 * @param {string=} options.context context of execution
-	 * @param {AsyncQueue<any, any, any>=} options.parent parent queue, which will have priority over this queue and with shared parallelism
+	 * @param {AsyncQueue<EXPECTED_ANY, EXPECTED_ANY, EXPECTED_ANY>=} options.parent parent queue, which will have priority over this queue and with shared parallelism
 	 * @param {getKey<T, K>=} options.getKey extract key from item
 	 * @param {Processor<T, R>} options.processor async function to process items
 	 */
@@ -80,18 +81,18 @@ class AsyncQueue {
 		this._processor = processor;
 		this._getKey =
 			getKey ||
-			/** @type {getKey<T, K>} */ (item => /** @type {T & K} */ (item));
+			/** @type {getKey<T, K>} */ ((item) => /** @type {T & K} */ (item));
 		/** @type {Map<K, AsyncQueueEntry<T, K, R>>} */
 		this._entries = new Map();
 		/** @type {ArrayQueue<AsyncQueueEntry<T, K, R>>} */
 		this._queued = new ArrayQueue();
-		/** @type {AsyncQueue<any, any, any>[] | undefined} */
+		/** @type {AsyncQueue<T, K, R>[] | undefined} */
 		this._children = undefined;
 		this._activeTasks = 0;
 		this._willEnsureProcessing = false;
 		this._needProcessing = false;
 		this._stopped = false;
-		/** @type {AsyncQueue<any, any, any>} */
+		/** @type {AsyncQueue<T, K, R>} */
 		this._root = parent ? parent._root : this;
 		if (parent) {
 			if (this._root._children === undefined) {
@@ -138,7 +139,7 @@ class AsyncQueue {
 	 */
 	add(item, callback) {
 		if (this._stopped) return callback(new WebpackError("Queue was stopped"));
-		this.hooks.beforeAdd.callAsync(item, err => {
+		this.hooks.beforeAdd.callAsync(item, (err) => {
 			if (err) {
 				callback(
 					makeWebpackError(err, `AsyncQueue(${this._name}).hooks.beforeAdd`)
@@ -327,7 +328,7 @@ class AsyncQueue {
 	 * @returns {void}
 	 */
 	_startProcessing(entry) {
-		this.hooks.beforeStart.callAsync(entry.item, err => {
+		this.hooks.beforeStart.callAsync(entry.item, (err) => {
 			if (err) {
 				this._handleResult(
 					entry,
@@ -356,7 +357,7 @@ class AsyncQueue {
 	 * @returns {void}
 	 */
 	_handleResult(entry, err, result) {
-		this.hooks.result.callAsync(entry.item, err, result, hookError => {
+		this.hooks.result.callAsync(entry.item, err, result, (hookError) => {
 			const error = hookError
 				? makeWebpackError(hookError, `AsyncQueue(${this._name}).hooks.result`)
 				: err;

package/lib/util/Hash.js

@@ -5,17 +5,35 @@
 
 "use strict";
 
+/** @typedef {import("../../declarations/WebpackOptions").HashDigest} Encoding */
+
 class Hash {
 	/* istanbul ignore next */
 	/**
 	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
 	 * @abstract
-	 * @param {string|Buffer} data data
-	 * @param {string=} inputEncoding data encoding
-	 * @returns {this} updated hash
+	 * @overload
+	 * @param {string | Buffer} data data
+	 * @returns {Hash} updated hash
+	 */
+	/**
+	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+	 * @abstract
+	 * @overload
+	 * @param {string} data data
+	 * @param {Encoding} inputEncoding data encoding
+	 * @returns {Hash} updated hash
+	 */
+	/**
+	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+	 * @abstract
+	 * @param {string | Buffer} data data
+	 * @param {Encoding=} inputEncoding data encoding
+	 * @returns {Hash} updated hash
 	 */
 	update(data, inputEncoding) {
 		const AbstractMethodError = require("../AbstractMethodError");
+
 		throw new AbstractMethodError();
 	}
 
@@ -23,11 +41,25 @@ class Hash {
 	/**
 	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
 	 * @abstract
-	 * @param {string=} encoding encoding of the return value
-	 * @returns {string|Buffer} digest
+	 * @overload
+	 * @returns {Buffer} digest
+	 */
+	/**
+	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+	 * @abstract
+	 * @overload
+	 * @param {Encoding} encoding encoding of the return value
+	 * @returns {string} digest
+	 */
+	/**
+	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+	 * @abstract
+	 * @param {Encoding=} encoding encoding of the return value
+	 * @returns {string | Buffer} digest
 	 */
 	digest(encoding) {
 		const AbstractMethodError = require("../AbstractMethodError");
+
 		throw new AbstractMethodError();
 	}
 }

package/lib/util/IterableHelpers.js

@@ -10,7 +10,7 @@
  * @param {Iterable<T>} set a set
  * @returns {T | undefined} last item
  */
-const last = set => {
+const last = (set) => {
 	let last;
 	for (const item of set) last = item;
 	return last;
@@ -19,7 +19,7 @@ const last = set => {
 /**
  * @template T
  * @param {Iterable<T>} iterable iterable
- * @param {function(T): boolean | null | undefined} filter predicate
+ * @param {(value: T) => boolean | null | undefined} filter predicate
  * @returns {boolean} true, if some items match the filter predicate
  */
 const someInIterable = (iterable, filter) => {
@@ -34,12 +34,12 @@ const someInIterable = (iterable, filter) => {
  * @param {Iterable<T>} iterable an iterable
  * @returns {number} count of items
  */
-const countIterable = iterable => {
+const countIterable = (iterable) => {
 	let i = 0;
 	for (const _ of iterable) i++;
 	return i;
 };
 
+module.exports.countIterable = countIterable;
 module.exports.last = last;
 module.exports.someInIterable = someInIterable;
-module.exports.countIterable = countIterable;

package/lib/util/LazyBucketSortedSet.js

@@ -10,12 +10,25 @@ const SortableSet = require("./SortableSet");
 
 /**
  * @template T
- * @typedef {LazyBucketSortedSet<T, any> | SortableSet<T>} Entry
+ * @template K
+ * @typedef {(item: T) => K} GetKey
  */
 
 /**
  * @template T
- * @typedef {(function(T): any) | (function(any, any): number)} Arg
+ * @typedef {(a: T, n: T) => number} Comparator
+ */
+
+/**
+ * @template T
+ * @template K
+ * @typedef {LazyBucketSortedSet<T, K> | SortableSet<T>} Entry
+ */
+
+/**
+ * @template T
+ * @template K
+ * @typedef {GetKey<T, K> | Comparator<K> | Comparator<T>} Arg
  */
 
 /**
@@ -32,17 +45,16 @@ const SortableSet = require("./SortableSet");
  */
 class LazyBucketSortedSet {
 	/**
-	 * @param {function(T): K} getKey function to get key from item
-	 * @param {function(K, K): number} comparator comparator to sort keys
-	 * @param  {...Arg<T>} args more pairs of getKey and comparator plus optional final comparator for the last layer
+	 * @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
 	 */
 	constructor(getKey, comparator, ...args) {
 		this._getKey = getKey;
-		/** @type {Arg<T>[]} */
 		this._innerArgs = args;
 		this._leaf = args.length <= 1;
 		this._keys = new SortableSet(undefined, comparator);
-		/** @type {Map<K, Entry<T>>} */
+		/** @type {Map<K, Entry<T, K>>} */
 		this._map = new Map();
 		this._unsortedItems = new Set();
 		this.size = 0;
@@ -65,18 +77,20 @@ class LazyBucketSortedSet {
 	_addInternal(key, item) {
 		let entry = this._map.get(key);
 		if (entry === undefined) {
-			entry =
-				/** @type {Entry<T>} */
-				(
-					this._leaf
-						? new SortableSet(undefined, this._innerArgs[0])
-						: new /** @type {TODO} */ (LazyBucketSortedSet)(...this._innerArgs)
-				);
+			entry = this._leaf
+				? new SortableSet(
+						undefined,
+						/** @type {Comparator<T>} */
+						(this._innerArgs[0])
+					)
+				: new LazyBucketSortedSet(
+						.../** @type {[GetKey<T, K>, Comparator<K>]} */
+						(this._innerArgs)
+					);
 			this._keys.add(key);
 			this._map.set(key, entry);
 		}
-		/** @type {Entry<T>} */
-		(entry).add(item);
+		entry.add(item);
 	}
 
 	/**
@@ -90,7 +104,7 @@ class LazyBucketSortedSet {
 			return;
 		}
 		const key = this._getKey(item);
-		const entry = /** @type {Entry<T>} */ (this._map.get(key));
+		const entry = /** @type {Entry<T, K>} */ (this._map.get(key));
 		entry.delete(item);
 		if (entry.size === 0) {
 			this._deleteKey(key);
@@ -132,7 +146,9 @@ class LazyBucketSortedSet {
 			}
 			return item;
 		}
-		const nodeEntry = /** @type {LazyBucketSortedSet<T, any>} */ (entry);
+		const nodeEntry =
+			/** @type {LazyBucketSortedSet<T, K>} */
+			(entry);
 		const item = nodeEntry.popFirst();
 		if (nodeEntry.size === 0) {
 			this._deleteKey(key);
@@ -142,11 +158,11 @@ class LazyBucketSortedSet {
 
 	/**
 	 * @param {T} item to be updated item
-	 * @returns {function(true=): void} finish update
+	 * @returns {(remove?: true) => void} finish update
 	 */
 	startUpdate(item) {
 		if (this._unsortedItems.has(item)) {
-			return remove => {
+			return (remove) => {
 				if (remove) {
 					this._unsortedItems.delete(item);
 					this.size--;
@@ -156,7 +172,7 @@ class LazyBucketSortedSet {
 		const key = this._getKey(item);
 		if (this._leaf) {
 			const oldEntry = /** @type {SortableSet<T>} */ (this._map.get(key));
-			return remove => {
+			return (remove) => {
 				if (remove) {
 					this.size--;
 					oldEntry.delete(item);
@@ -178,11 +194,11 @@ class LazyBucketSortedSet {
 				}
 			};
 		}
-		const oldEntry = /** @type {LazyBucketSortedSet<T, any>} */ (
-			this._map.get(key)
-		);
+		const oldEntry =
+			/** @type {LazyBucketSortedSet<T, K>} */
+			(this._map.get(key));
 		const finishUpdate = oldEntry.startUpdate(item);
-		return remove => {
+		return (remove) => {
 			if (remove) {
 				this.size--;
 				finishUpdate(true);
@@ -209,8 +225,9 @@ class LazyBucketSortedSet {
 	 * @returns {void}
 	 */
 	_appendIterators(iterators) {
-		if (this._unsortedItems.size > 0)
+		if (this._unsortedItems.size > 0) {
 			iterators.push(this._unsortedItems[Symbol.iterator]());
+		}
 		for (const key of this._keys) {
 			const entry = this._map.get(key);
 			if (this._leaf) {
@@ -218,7 +235,9 @@ class LazyBucketSortedSet {
 				const iterator = leafEntry[Symbol.iterator]();
 				iterators.push(iterator);
 			} else {
-				const nodeEntry = /** @type {LazyBucketSortedSet<T, any>} */ (entry);
+				const nodeEntry =
+					/** @type {LazyBucketSortedSet<T, K>} */
+					(entry);
 				nodeEntry._appendIterators(iterators);
 			}
 		}