webpack 5.99.8 → 5.100.0

package/lib/url/URLParserPlugin.js

@@ -0,0 +1,266 @@
+/*
+	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("../ContextModule").ContextMode} ContextMode */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser")} Parser */
+/** @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 {Parser} 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 {Parser} 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/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");

package/lib/util/Hash.js

@@ -16,6 +16,7 @@ class Hash {
 	 */
 	update(data, inputEncoding) {
 		const AbstractMethodError = require("../AbstractMethodError");
+
 		throw new AbstractMethodError();
 	}
 
@@ -28,6 +29,7 @@ class Hash {
 	 */
 	digest(encoding) {
 		const AbstractMethodError = require("../AbstractMethodError");
+
 		throw new AbstractMethodError();
 	}
 }

package/lib/util/IterableHelpers.js

@@ -40,6 +40,6 @@ const countIterable = iterable => {
 	return i;
 };
 
+module.exports.countIterable = countIterable;
 module.exports.last = last;
 module.exports.someInIterable = someInIterable;
-module.exports.countIterable = countIterable;

package/lib/util/LazyBucketSortedSet.js

@@ -225,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) {

package/lib/util/LazySet.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const makeSerializable = require("./makeSerializable.js");
+const makeSerializable = require("./makeSerializable");
 
 /**
  * @template T
@@ -39,6 +39,11 @@ const flatten = (targetSet, toDeepMerge) => {
 	}
 };
 
+/**
+ * @template T
+ * @typedef {import("typescript-iterable").SetIterator<T>} SetIterator
+ */
+
 /**
  * Like Set but with an addAll method to eventually add items from another iterable.
  * Access methods make sure that all delayed operations are executed.
@@ -139,7 +144,7 @@ class LazySet {
 	}
 
 	/**
-	 * @returns {IterableIterator<[T, T]>} entries
+	 * @returns {SetIterator<[T, T]>} entries
 	 */
 	entries() {
 		this._deopt = true;
@@ -156,7 +161,7 @@ class LazySet {
 	forEach(callbackFn, thisArg) {
 		this._deopt = true;
 		if (this._needMerge) this._merge();
-		// eslint-disable-next-line unicorn/no-array-for-each
+		// eslint-disable-next-line unicorn/no-array-for-each, unicorn/no-array-method-this-argument
 		this._set.forEach(callbackFn, thisArg);
 	}
 
@@ -170,7 +175,7 @@ class LazySet {
 	}
 
 	/**
-	 * @returns {IterableIterator<T>} keys
+	 * @returns {SetIterator<T>} keys
 	 */
 	keys() {
 		this._deopt = true;
@@ -179,7 +184,7 @@ class LazySet {
 	}
 
 	/**
-	 * @returns {IterableIterator<T>} values
+	 * @returns {SetIterator<T>} values
 	 */
 	values() {
 		this._deopt = true;
@@ -188,7 +193,7 @@ class LazySet {
 	}
 
 	/**
-	 * @returns {IterableIterator<T>} iterable iterator
+	 * @returns {SetIterator<T>} iterable iterator
 	 */
 	[Symbol.iterator]() {
 		this._deopt = true;

package/lib/util/ParallelismFactorCalculator.js

@@ -31,7 +31,7 @@ class ParallelismFactorCalculator {
 	}
 
 	calculate() {
-		const segments = Array.from(new Set(this._rangePoints)).sort((a, b) =>
+		const segments = [...new Set(this._rangePoints)].sort((a, b) =>
 			a < b ? -1 : 1
 		);
 		const parallelism = segments.map(() => 0);

package/lib/util/SetHelpers.js

@@ -87,8 +87,8 @@ const combine = (a, b) => {
 	return set;
 };
 
-module.exports.intersect = intersect;
-module.exports.isSubset = isSubset;
+module.exports.combine = combine;
 module.exports.find = find;
 module.exports.first = first;
-module.exports.combine = combine;
+module.exports.intersect = intersect;
+module.exports.isSubset = isSubset;

package/lib/util/SortableSet.js

@@ -88,7 +88,7 @@ class SortableSet extends Set {
 			return;
 		}
 
-		const sortedArray = Array.from(this).sort(sortFn);
+		const sortedArray = [...this].sort(sortFn);
 		super.clear();
 		for (let i = 0; i < sortedArray.length; i += 1) {
 			super.add(sortedArray[i]);
@@ -168,7 +168,7 @@ class SortableSet extends Set {
 	 * @returns {T[]} the raw array
 	 */
 	toJSON() {
-		return Array.from(this);
+		return [...this];
 	}
 }
 

package/lib/util/StackedCacheMap.js

@@ -5,6 +5,8 @@
 
 "use strict";
 
+new Map().entries();
+
 /**
  * The StackedCacheMap is a data structure designed as an alternative to a Map
  * in situations where you need to handle multiple item additions and
@@ -128,7 +130,7 @@ class StackedCacheMap {
 			next() {
 				let result = current.next();
 				while (result.done && iterators.length > 0) {
-					current = /** @type {IterableIterator<[K, V]>} */ (iterators.pop());
+					current = /** @type {MapIterator<[K, V]>} */ (iterators.pop());
 					result = current.next();
 				}
 				return result;

package/lib/util/StackedMap.js

@@ -45,7 +45,7 @@ class StackedMap {
 		/** @type {Map<K, InternalCell<V>>} */
 		this.map = new Map();
 		/** @type {Map<K, InternalCell<V>>[]} */
-		this.stack = parentStack === undefined ? [] : parentStack.slice();
+		this.stack = parentStack === undefined ? [] : [...parentStack];
 		this.stack.push(this.map);
 	}
 
@@ -134,7 +134,7 @@ class StackedMap {
 
 	asArray() {
 		this._compress();
-		return Array.from(this.map.keys());
+		return [...this.map.keys()];
 	}
 
 	asSet() {

package/lib/util/StringXor.js

@@ -71,6 +71,7 @@ class StringXor {
 			}
 		} else {
 			for (let i = 0; i < len; i++) {
+				// eslint-disable-next-line operator-assignment
 				value[i] = value[i] ^ str.charCodeAt(i);
 			}
 		}

package/lib/util/TupleSet.js

@@ -165,6 +165,7 @@ class TupleSet {
 						return {
 							done: false,
 							value:
+								/* eslint-disable unicorn/prefer-spread */
 								/** @type {[T, V, ...EXPECTED_ANY]} */
 								(tuple.concat(result.value))
 						};

package/lib/util/URLAbsoluteSpecifier.js

@@ -83,5 +83,5 @@ function getProtocol(specifier) {
 	return scheme === undefined ? undefined : `${scheme}:`;
 }
 
-module.exports.getScheme = getScheme;
 module.exports.getProtocol = getProtocol;
+module.exports.getScheme = getScheme;

package/lib/util/cleverMerge.js

@@ -30,10 +30,12 @@ const DYNAMIC_INFO = Symbol("cleverMerge dynamic info");
 const cachedCleverMerge = (first, second) => {
 	if (second === undefined) return /** @type {T} */ (first);
 	if (first === undefined) return /** @type {O} */ (second);
-	if (typeof second !== "object" || second === null)
+	if (typeof second !== "object" || second === null) {
 		return /** @type {O} */ (second);
-	if (typeof first !== "object" || first === null)
+	}
+	if (typeof first !== "object" || first === null) {
 		return /** @type {T} */ (first);
+	}
 
 	let innerCache = mergeCache.get(first);
 	if (innerCache === undefined) {
@@ -171,9 +173,10 @@ const parseObject = obj => {
 										/** @type {ByValues<V>} */
 										(entry.byValues).has(otherByValue)
 									)
-								)
+								) {
 									/** @type {ByValues<V>} */
 									(entry.byValues).set(otherByValue, undefined);
+								}
 							}
 						}
 					}
@@ -424,7 +427,7 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 				);
 			}
 			if (
-				Array.from(firstEntry.byValues.values()).every(value => {
+				[...firstEntry.byValues.values()].every(value => {
 					const type = getValueType(value);
 					return type === VALUE_TYPE_ATOM || type === VALUE_TYPE_DELETE;
 				})
@@ -438,8 +441,9 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 			} else {
 				// = first.base + ((first.byProperty (+default) + second.base) + second.byProperty)
 				newBase = firstEntry.base;
-				if (!intermediateByValues.has("default"))
+				if (!intermediateByValues.has("default")) {
 					intermediateByValues.set("default", secondEntry.base);
+				}
 			}
 			if (!secondEntry.byProperty) {
 				// = first.base + (first.byProperty + second.base)
@@ -629,9 +633,9 @@ const resolveByProperty = (obj, byProperty, ...values) => {
 	return obj;
 };
 
-module.exports.cachedSetProperty = cachedSetProperty;
+module.exports.DELETE = DELETE;
 module.exports.cachedCleverMerge = cachedCleverMerge;
+module.exports.cachedSetProperty = cachedSetProperty;
 module.exports.cleverMerge = cleverMerge;
-module.exports.resolveByProperty = resolveByProperty;
 module.exports.removeOperations = removeOperations;
-module.exports.DELETE = DELETE;
+module.exports.resolveByProperty = resolveByProperty;