webpack 5.99.9 → 5.100.0

package/lib/stats/DefaultStatsPresetPlugin.js

@@ -384,13 +384,13 @@ class DefaultStatsPresetPlugin {
 				const defaults = NAMED_PRESETS[/** @type {keyof NamedPresets} */ (key)];
 				compilation.hooks.statsPreset
 					.for(key)
-					.tap(PLUGIN_NAME, (options, context) => {
+					.tap(PLUGIN_NAME, (options, _context) => {
 						applyDefaults(options, defaults);
 					});
 			}
 			compilation.hooks.statsNormalize.tap(PLUGIN_NAME, (options, context) => {
 				for (const key of Object.keys(DEFAULTS)) {
-					if (options[key] === undefined)
+					if (options[key] === undefined) {
 						options[key] =
 							/** @type {Defaults[DefaultsKeys]} */
 							(DEFAULTS[/** @type {DefaultsKeys} */ (key)])(
@@ -398,6 +398,7 @@ class DefaultStatsPresetPlugin {
 								context,
 								compilation
 							);
+					}
 				}
 				for (const key of Object.keys(NORMALIZER)) {
 					options[key] =
@@ -408,4 +409,5 @@ class DefaultStatsPresetPlugin {
 		});
 	}
 }
+
 module.exports = DefaultStatsPresetPlugin;

package/lib/stats/DefaultStatsPrinterPlugin.js

@@ -277,8 +277,9 @@ const COMPILATION_SIMPLE_PRINTERS = {
 			(errorsCount === 0 && warningsCount === 0) ||
 			timeMessage ||
 			hashMessage
-		)
+		) {
 			return `${builtAtMessage}${subjectMessage} ${statusMessage}${timeMessage}${hashMessage}`;
+		}
 	},
 	"compilation.filteredWarningDetailsCount": count =>
 		count
@@ -493,7 +494,7 @@ const MODULE_SIMPLE_PRINTERS = {
 		const [prefix, resource] = getModuleName(name);
 		return `${prefix || ""}${bold(resource || "")}`;
 	},
-	"module.identifier": identifier => undefined,
+	"module.identifier": _identifier => undefined,
 	"module.layer": (layer, { formatLayer }) =>
 		layer ? formatLayer(layer) : undefined,
 	"module.sizes": printSizes,
@@ -547,8 +548,9 @@ const MODULE_SIMPLE_PRINTERS = {
 			if (usedExports === null) return cyan(formatFlag("used exports unknown"));
 			if (usedExports === false) return cyan(formatFlag("module unused"));
 			if (Array.isArray(usedExports)) {
-				if (usedExports.length === 0)
+				if (usedExports.length === 0) {
 					return cyan(formatFlag("no exports used"));
+				}
 				const providedExportsCount = Array.isArray(module.providedExports)
 					? module.providedExports.length
 					: null;
@@ -569,7 +571,7 @@ const MODULE_SIMPLE_PRINTERS = {
 		yellow(optimizationBailout),
 	"module.issuerPath": (issuerPath, { module }) =>
 		module.profile ? undefined : "",
-	"module.profile": profile => undefined,
+	"module.profile": _profile => undefined,
 	"module.filteredModules": (filteredModules, { module: { modules } }) =>
 		filteredModules > 0
 			? `${moreCount(modules, filteredModules)} nested ${plural(
@@ -829,7 +831,7 @@ const ERROR_PRINTERS = {
 					"  "
 				)
 			: undefined,
-	"error.moduleTrace": moduleTrace => undefined,
+	"error.moduleTrace": _moduleTrace => undefined,
 	"error.separator!": () => "\n"
 };
 
@@ -1407,15 +1409,17 @@ const SIMPLE_ELEMENT_JOINERS = {
 			items.map(item => {
 				switch (item.element) {
 					case "moduleId":
-						if (moduleReason.moduleId === moduleReason.module && item.content)
+						if (moduleReason.moduleId === moduleReason.module && item.content) {
 							hasName = true;
+						}
 						break;
 					case "module":
 						if (hasName) return false;
 						break;
 					case "resolvedModule":
-						if (moduleReason.module === moduleReason.resolvedModule)
+						if (moduleReason.module === moduleReason.resolvedModule) {
 							return false;
+						}
 						break;
 					case "children":
 						if (item.content) {
@@ -1564,7 +1568,7 @@ const RESULT_MODIFIER = {
  * @returns {string[]} result
  */
 const createOrder = (array, preferredOrder) => {
-	const originalArray = array.slice();
+	const originalArray = [...array];
 	/** @type {Set<string>} */
 	const set = new Set(array);
 	/** @type {Set<string>} */
@@ -1621,6 +1625,7 @@ class DefaultStatsPrinterPlugin {
 									`${start}${
 										typeof str === "string"
 											? str.replace(
+													// eslint-disable-next-line no-control-regex
 													/((\u001B\[39m|\u001B\[22m|\u001B\[0m)+)/g,
 													`$1${start}`
 												)
@@ -1851,7 +1856,7 @@ class DefaultStatsPrinterPlugin {
 					const preferredOrder = PREFERRED_ORDERS[key];
 					stats.hooks.sortElements
 						.for(key)
-						.tap(PLUGIN_NAME, (elements, context) => {
+						.tap(PLUGIN_NAME, (elements, _context) => {
 							createOrder(elements, preferredOrder);
 						});
 				}
@@ -1886,4 +1891,5 @@ class DefaultStatsPrinterPlugin {
 		});
 	}
 }
+
 module.exports = DefaultStatsPrinterPlugin;

package/lib/stats/StatsFactory.js

@@ -205,7 +205,7 @@ class StatsFactory {
 	 */
 	_forEachLevelFilter(hookMap, cache, type, items, fn, forceClone) {
 		const hooks = this._getAllLevelHooks(hookMap, cache, type);
-		if (hooks.length === 0) return forceClone ? items.slice() : items;
+		if (hooks.length === 0) return forceClone ? [...items] : items;
 		let i = 0;
 		return items.filter((item, idx) => {
 			for (const hook of hooks) {
@@ -236,8 +236,9 @@ class StatsFactory {
 			this._inCreate = true;
 			return this._create(type, data, baseContext);
 		} finally {
-			for (const key of Object.keys(this._caches))
+			for (const key of Object.keys(this._caches)) {
 				this._caches[/** @type {keyof StatsFactoryHooks} */ (key)].clear();
+			}
 			this._inCreate = false;
 		}
 	}
@@ -397,4 +398,5 @@ class StatsFactory {
 		);
 	}
 }
+
 module.exports = StatsFactory;

package/lib/stats/StatsPrinter.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const { HookMap, SyncWaterfallHook, SyncBailHook } = require("tapable");
+const { HookMap, SyncBailHook, SyncWaterfallHook } = require("tapable");
 
 /** @typedef {import("./DefaultStatsFactoryPlugin").StatsAsset} StatsAsset */
 /** @typedef {import("./DefaultStatsFactoryPlugin").StatsChunk} StatsChunk */
@@ -217,7 +217,7 @@ class StatsPrinter {
 		);
 		if (printResult === undefined) {
 			if (Array.isArray(object)) {
-				const sortedItems = object.slice();
+				const sortedItems = [...object];
 				this._forEachLevel(this.hooks.sortItems, type, h =>
 					h.call(
 						sortedItems,
@@ -298,4 +298,5 @@ class StatsPrinter {
 		);
 	}
 }
+
 module.exports = StatsPrinter;

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;