webpack 5.108.3 → 5.109.0

package/lib/stats/DefaultStatsPresetPlugin.js

@@ -41,6 +41,7 @@ const NAMED_PRESETS = {
 		relatedAssets: true,
 		entrypoints: true,
 		chunkGroups: true,
+		chunkGroupResourceHints: true,
 		ids: true,
 		modules: false,
 		chunks: true,
@@ -210,6 +211,7 @@ const DEFAULTS = {
 	chunkGroups: OFF_FOR_TO_STRING,
 	chunkGroupAuxiliary: OFF_FOR_TO_STRING,
 	chunkGroupChildren: OFF_FOR_TO_STRING,
+	chunkGroupResourceHints: OFF_FOR_TO_STRING,
 	chunkGroupMaxAssets: (o, { forToString }) => (forToString ? 5 : Infinity),
 	chunks: OFF_FOR_TO_STRING,
 	chunkRelations: OFF_FOR_TO_STRING,

package/lib/stats/DefaultStatsPrinterPlugin.js

@@ -508,8 +508,18 @@ const MODULE_SIMPLE_PRINTERS = {
 	"module.chunks[]": (id, { formatChunkId }) => formatChunkId(id),
 	"module.depth": (depth, { formatFlag }) =>
 		depth !== null ? formatFlag(`depth ${depth}`) : undefined,
-	"module.cacheable": (cacheable, { formatFlag, red }) =>
-		cacheable === false ? red(formatFlag("not cacheable")) : undefined,
+	"module.cacheable": (cacheable, { formatFlag, red, module }) =>
+		cacheable === false
+			? red(
+					formatFlag(
+						module.notCacheableReasons && module.notCacheableReasons.length > 0
+							? `not cacheable: ${module.notCacheableReasons.join(", ")}`
+							: "not cacheable"
+					)
+				)
+			: undefined,
+	// rendered as part of the "module.cacheable" flag
+	"module.notCacheableReasons": () => undefined,
 	"module.orphan": (orphan, { formatFlag, yellow }) =>
 		orphan ? yellow(formatFlag("orphan")) : undefined,
 	// "module.runtime": (runtime, { formatFlag, yellow }) =>

package/lib/stats/StatsFactory.js

@@ -310,23 +310,30 @@ class StatsFactory {
 				false
 			);
 
-			// for each item
+			// reuse one item context; create() spreads it synchronously, so mutating
+			// `_index`/the name key between items is safe and skips a per-item spread
+			/** @type {StatsFactoryContext} */
+			const itemContext = { ...context };
+			const itemNameType = `${type}[]`;
+			/** @type {string | void} */
+			let prevItemName;
 			let resultItems = items2.map((item, i) => {
-				/** @type {StatsFactoryContext} */
-				const itemContext = {
-					...context,
-					_index: i
-				};
+				itemContext._index = i;
 
 				// run getItemName
 				const itemName = this._forEachLevel(
 					this.hooks.getItemName,
 					this._caches.getItemName,
-					`${type}[]`,
+					itemNameType,
 					(h) => h.call(item, itemContext)
 				);
+				// drop a previous item's name key before adding this one's
+				if (prevItemName !== undefined && prevItemName !== itemName) {
+					delete itemContext[prevItemName];
+				}
 				if (itemName) itemContext[itemName] = item;
-				const innerType = itemName ? `${type}[].${itemName}` : `${type}[]`;
+				prevItemName = itemName;
+				const innerType = itemName ? `${type}[].${itemName}` : itemNameType;
 
 				// run getItemFactory
 				const itemFactory =

package/lib/url/URLParserPlugin.js

@@ -9,6 +9,9 @@ const { pathToFileURL } = require("url");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const ConstDependency = require("../dependencies/ConstDependency");
 const ContextDependencyHelpers = require("../dependencies/ContextDependencyHelpers");
+const {
+	isImportMetaFieldEnabled
+} = require("../dependencies/ImportMetaPlugin");
 const URLContextDependency = require("../dependencies/URLContextDependency");
 const URLDependency = require("../dependencies/URLDependency");
 const CommentCompilationWarning = require("../errors/CommentCompilationWarning");
@@ -16,6 +19,7 @@ const UnsupportedFeatureWarning = require("../errors/UnsupportedFeatureWarning")
 const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
 const { approve } = require("../javascript/JavascriptParserHelpers");
 const { getInnerGraphUtils } = require("../optimize/InnerGraph");
+const ResourceHintPlugin = require("../prefetch/ResourceHintPlugin");
 
 /** @typedef {import("estree").MemberExpression} MemberExpression */
 /** @typedef {import("estree").NewExpression} NewExpressionNode */
@@ -56,6 +60,32 @@ const isMetaUrl = (parser, arg) => {
 	return true;
 };
 
+/**
+ * Whether the request points to a directory and thus can't be an asset.
+ * @param {string} request request
+ * @returns {boolean} true when the request is a directory reference
+ */
+const isDirectoryRequest = (request) =>
+	request === "." || request === ".." || request.endsWith("/");
+
+/**
+ * Replaces `import.meta.url` with the runtime base URI, leaving the
+ * `new URL(...)` construction untouched so it's evaluated at runtime.
+ * @param {JavascriptParser} parser parser
+ * @param {NewExpressionNode} expr expression
+ * @returns {void}
+ */
+const keepNewURL = (parser, expr) => {
+	const [, arg2] = expr.arguments;
+	const dep = new ConstDependency(
+		RuntimeGlobals.baseURI,
+		/** @type {Range} */ (arg2.range),
+		[RuntimeGlobals.baseURI]
+	);
+	dep.loc = parser.getLocation(expr);
+	parser.state.module.addPresentationalDependency(dep);
+};
+
 /** @type {WeakMap<NewExpressionNode, BasicEvaluatedExpression | undefined>} */
 const getEvaluatedExprCache = new WeakMap();
 
@@ -63,9 +93,10 @@ const getEvaluatedExprCache = new WeakMap();
  * Gets evaluated expr.
  * @param {NewExpressionNode} expr expression
  * @param {JavascriptParser} parser parser parser
+ * @param {boolean} importMetaUrlEnabled true when import.meta.url should be handled
  * @returns {BasicEvaluatedExpression | undefined} basic evaluated expression
  */
-const getEvaluatedExpr = (expr, parser) => {
+const getEvaluatedExpr = (expr, parser, importMetaUrlEnabled) => {
 	let result = getEvaluatedExprCache.get(expr);
 	if (result !== undefined) return result;
 
@@ -81,7 +112,9 @@ const getEvaluatedExpr = (expr, parser) => {
 		if (arg2.type !== "MemberExpression" || arg1.type === "SpreadElement") {
 			return;
 		}
-		if (!isMetaUrl(parser, arg2)) return;
+		if (!importMetaUrlEnabled || !isMetaUrl(parser, arg2)) {
+			return;
+		}
 
 		return parser.evaluateExpression(arg1);
 	};
@@ -92,6 +125,13 @@ const getEvaluatedExpr = (expr, parser) => {
 	return result;
 };
 
+/**
+ * @typedef {object} ResolvedResourceHints
+ * @property {boolean=} prefetch project-wide prefetch default
+ * @property {boolean=} preload project-wide preload default
+ * @property {("low" | "high" | "auto" | false)=} fetchPriority project-wide fetchPriority default
+ */
+
 class URLParserPlugin {
 	/**
 	 * Creates an instance of URLParserPlugin.
@@ -109,10 +149,18 @@ class URLParserPlugin {
 	 */
 	apply(parser) {
 		const relative = this.options.url === "relative";
+		const importMetaUrlEnabled = isImportMetaFieldEnabled(
+			this.options.importMeta,
+			"url"
+		);
 
 		parser.hooks.canRename.for("URL").tap(PLUGIN_NAME, approve);
 		parser.hooks.evaluateNewExpression.for("URL").tap(PLUGIN_NAME, (expr) => {
-			const evaluatedExpr = getEvaluatedExpr(expr, parser);
+			const evaluatedExpr = getEvaluatedExpr(
+				expr,
+				parser,
+				importMetaUrlEnabled
+			);
 			const request = evaluatedExpr && evaluatedExpr.asString();
 
 			if (!request) return;
@@ -133,7 +181,7 @@ class URLParserPlugin {
 					parser.state.module.addWarning(
 						new CommentCompilationWarning(
 							`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
-							/** @type {DependencyLocation} */ (comment.loc)
+							parser.getLocation(comment)
 						)
 					);
 				}
@@ -144,7 +192,7 @@ class URLParserPlugin {
 					parser.state.module.addWarning(
 						new UnsupportedFeatureWarning(
 							`\`webpackIgnore\` expected a boolean, but received: ${importOptions.webpackIgnore}.`,
-							/** @type {DependencyLocation} */ (expr.loc)
+							parser.getLocation(expr)
 						)
 					);
 					return;
@@ -153,23 +201,25 @@ class URLParserPlugin {
 
 					const [, arg2] = expr.arguments;
 
-					if (arg2.type !== "MemberExpression" || !isMetaUrl(parser, arg2)) {
+					if (
+						arg2.type !== "MemberExpression" ||
+						!importMetaUrlEnabled ||
+						!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);
+					keepNewURL(parser, expr);
 
 					return true;
 				}
 			}
 
-			const evaluatedExpr = getEvaluatedExpr(expr, parser);
+			const evaluatedExpr = getEvaluatedExpr(
+				expr,
+				parser,
+				importMetaUrlEnabled
+			);
 			if (!evaluatedExpr) return;
 
 			/** @type {string | undefined} */
@@ -177,6 +227,12 @@ class URLParserPlugin {
 
 			// static URL
 			if ((request = evaluatedExpr.asString())) {
+				// A directory is not an asset; keep `new URL(...)` as-is, matching Node/browsers.
+				if (isDirectoryRequest(request)) {
+					keepNewURL(parser, expr);
+					return true;
+				}
+
 				const [arg1, arg2] = expr.arguments;
 				const dep = new URLDependency(
 					request,
@@ -187,8 +243,27 @@ class URLParserPlugin {
 					/** @type {Range} */ (expr.range),
 					relative
 				);
-				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				dep.loc = parser.getLocation(expr);
+				// `parser.javascript.urlHints` provides project-wide defaults
+				// (resolved per-request, with `test` / `include` / `exclude`
+				// matching); a per-URL magic comment for the same hint wins
+				// when both are set.
+				ResourceHintPlugin.applyResourceHints(
+					dep,
+					this.options.urlHints,
+					request,
+					importOptions,
+					parser.state.module,
+					parser.getLocation(expr)
+				);
 				parser.state.current.addDependency(dep);
+				// For ESM module output the template embeds the asset's resolved
+				// filename, so the asset must be code-generated first. Only added in
+				// that mode — a code-gen dependency on an asset that a later watch
+				// rebuild leaves unaffected can otherwise deadlock the scheduler.
+				if (parser.state.compilation.options.output.module) {
+					parser.state.module.addCodeGenerationDependency(dep);
+				}
 				getInnerGraphUtils(parser.state.compilation).onUsage(
 					parser.state,
 					(e) => (dep.usedByExports = e)
@@ -213,7 +288,7 @@ class URLParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackInclude\` expected a regular expression, but received: ${importOptions.webpackInclude}.`,
-								/** @type {DependencyLocation} */ (expr.loc)
+								parser.getLocation(expr)
 							)
 						);
 					} else {
@@ -228,7 +303,7 @@ class URLParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackExclude\` expected a regular expression, but received: ${importOptions.webpackExclude}.`,
-								/** @type {DependencyLocation} */ (expr.loc)
+								parser.getLocation(expr)
 							)
 						);
 					} else {
@@ -252,7 +327,7 @@ class URLParserPlugin {
 				parser
 			);
 			if (!dep) return;
-			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			dep.loc = parser.getLocation(expr);
 			dep.optional = Boolean(parser.scope.inTry);
 			parser.state.current.addDependency(dep);
 			return true;
@@ -264,7 +339,11 @@ class URLParserPlugin {
 			const calleeInfo = parser.getFreeInfoFromVariable(callee.name);
 			if (!calleeInfo || calleeInfo.name !== "URL") return;
 
-			const evaluatedExpr = getEvaluatedExpr(expr, parser);
+			const evaluatedExpr = getEvaluatedExpr(
+				expr,
+				parser,
+				importMetaUrlEnabled
+			);
 			const request = evaluatedExpr && evaluatedExpr.asString();
 
 			if (request) return true;

package/lib/util/AsyncQueue.js

@@ -159,6 +159,11 @@ class AsyncQueue {
 	 */
 	add(item, callback) {
 		if (this._stopped) return callback(new WebpackError("Queue was stopped"));
+		// skip async hook dispatch when unused — this runs per module × queue
+		if (!this.hooks.beforeAdd.isUsed()) {
+			this._add(item, callback);
+			return;
+		}
 		this.hooks.beforeAdd.callAsync(item, (err) => {
 			if (err) {
 				callback(
@@ -166,42 +171,52 @@ class AsyncQueue {
 				);
 				return;
 			}
-			const key = this._getKey(item);
-			const entry = this._entries.get(key);
-			if (entry !== undefined) {
-				if (entry.state === DONE_STATE) {
-					if (inHandleResult++ > 3) {
-						process.nextTick(() => callback(entry.error, entry.result));
-					} else {
-						callback(entry.error, entry.result);
-					}
-					inHandleResult--;
-				} else if (entry.callbacks === undefined) {
-					entry.callbacks = [callback];
+			this._add(item, callback);
+		});
+	}
+
+	/**
+	 * Processes the provided item, after the beforeAdd hook.
+	 * @param {T} item an item
+	 * @param {Callback<R>} callback callback function
+	 * @returns {void}
+	 */
+	_add(item, callback) {
+		const key = this._getKey(item);
+		const entry = this._entries.get(key);
+		if (entry !== undefined) {
+			if (entry.state === DONE_STATE) {
+				if (inHandleResult++ > 3) {
+					process.nextTick(() => callback(entry.error, entry.result));
 				} else {
-					entry.callbacks.push(callback);
+					callback(entry.error, entry.result);
 				}
-				return;
-			}
-			const newEntry = new AsyncQueueEntry(item, callback);
-			if (this._stopped) {
-				this.hooks.added.call(item);
-				this._root._activeTasks++;
-				process.nextTick(() =>
-					this._handleResult(newEntry, new WebpackError("Queue was stopped"))
-				);
+				inHandleResult--;
+			} else if (entry.callbacks === undefined) {
+				entry.callbacks = [callback];
 			} else {
-				this._entries.set(key, newEntry);
-				this._queued.enqueue(newEntry);
-				const root = this._root;
-				root._needProcessing = true;
-				if (root._willEnsureProcessing === false) {
-					root._willEnsureProcessing = true;
-					setImmediate(root._ensureProcessing);
-				}
-				this.hooks.added.call(item);
+				entry.callbacks.push(callback);
 			}
-		});
+			return;
+		}
+		const newEntry = new AsyncQueueEntry(item, callback);
+		if (this._stopped) {
+			this.hooks.added.call(item);
+			this._root._activeTasks++;
+			process.nextTick(() =>
+				this._handleResult(newEntry, new WebpackError("Queue was stopped"))
+			);
+		} else {
+			this._entries.set(key, newEntry);
+			this._queued.enqueue(newEntry);
+			const root = this._root;
+			root._needProcessing = true;
+			if (root._willEnsureProcessing === false) {
+				root._willEnsureProcessing = true;
+				setImmediate(root._ensureProcessing);
+			}
+			this.hooks.added.call(item);
+		}
 	}
 
 	/**
@@ -357,6 +372,11 @@ class AsyncQueue {
 	 * @returns {void}
 	 */
 	_startProcessing(entry) {
+		// skip async hook dispatch when unused — this runs per module × queue
+		if (!this.hooks.beforeStart.isUsed()) {
+			this._startProcessing2(entry);
+			return;
+		}
 		this.hooks.beforeStart.callAsync(entry.item, (err) => {
 			if (err) {
 				this._handleResult(
@@ -365,20 +385,29 @@ class AsyncQueue {
 				);
 				return;
 			}
-			let inCallback = false;
-			try {
-				this._processor(entry.item, (e, r) => {
-					inCallback = true;
-					this._handleResult(entry, e, r);
-				});
-			} catch (err) {
-				if (inCallback) throw err;
-				this._handleResult(entry, /** @type {WebpackError} */ (err), null);
-			}
-			this.hooks.started.call(entry.item);
+			this._startProcessing2(entry);
 		});
 	}
 
+	/**
+	 * Processes the provided entry, after the beforeStart hook.
+	 * @param {AsyncQueueEntry<T, K, R>} entry the entry
+	 * @returns {void}
+	 */
+	_startProcessing2(entry) {
+		let inCallback = false;
+		try {
+			this._processor(entry.item, (e, r) => {
+				inCallback = true;
+				this._handleResult(entry, e, r);
+			});
+		} catch (err) {
+			if (inCallback) throw err;
+			this._handleResult(entry, /** @type {WebpackError} */ (err), null);
+		}
+		this.hooks.started.call(entry.item);
+	}
+
 	/**
 	 * Processes the provided entry.
 	 * @param {AsyncQueueEntry<T, K, R>} entry the entry
@@ -387,45 +416,66 @@ class AsyncQueue {
 	 * @returns {void}
 	 */
 	_handleResult(entry, err, result) {
+		// skip async hook dispatch when unused — this runs per module × queue
+		if (!this.hooks.result.isUsed()) {
+			this._handleResult2(entry, err, result);
+			return;
+		}
 		this.hooks.result.callAsync(entry.item, err, result, (hookError) => {
-			const error = hookError
-				? makeWebpackError(hookError, `AsyncQueue(${this._name}).hooks.result`)
-				: err;
-
-			const callback = /** @type {Callback<R>} */ (entry.callback);
-			const callbacks = entry.callbacks;
-			entry.state = DONE_STATE;
-			entry.callback = undefined;
-			entry.callbacks = undefined;
-			entry.result = result;
-			entry.error = error;
+			this._handleResult2(
+				entry,
+				hookError
+					? makeWebpackError(
+							hookError,
+							`AsyncQueue(${this._name}).hooks.result`
+						)
+					: err,
+				result
+			);
+		});
+	}
 
-			const root = this._root;
-			root._activeTasks--;
-			if (root._willEnsureProcessing === false && root._needProcessing) {
-				root._willEnsureProcessing = true;
-				setImmediate(root._ensureProcessing);
-			}
+	/**
+	 * Finalizes the provided entry, after the result hook.
+	 * @param {AsyncQueueEntry<T, K, R>} entry the entry
+	 * @param {(WebpackError | null)=} error error, if any
+	 * @param {(R | null)=} result result, if any
+	 * @returns {void}
+	 */
+	_handleResult2(entry, error, result) {
+		const callback = /** @type {Callback<R>} */ (entry.callback);
+		const callbacks = entry.callbacks;
+		entry.state = DONE_STATE;
+		entry.callback = undefined;
+		entry.callbacks = undefined;
+		entry.result = result;
+		entry.error = error;
 
-			if (inHandleResult++ > 3) {
-				process.nextTick(() => {
-					callback(error, result);
-					if (callbacks !== undefined) {
-						for (const callback of callbacks) {
-							callback(error, result);
-						}
-					}
-				});
-			} else {
+		const root = this._root;
+		root._activeTasks--;
+		if (root._willEnsureProcessing === false && root._needProcessing) {
+			root._willEnsureProcessing = true;
+			setImmediate(root._ensureProcessing);
+		}
+
+		if (inHandleResult++ > 3) {
+			process.nextTick(() => {
 				callback(error, result);
 				if (callbacks !== undefined) {
 					for (const callback of callbacks) {
 						callback(error, result);
 					}
 				}
+			});
+		} else {
+			callback(error, result);
+			if (callbacks !== undefined) {
+				for (const callback of callbacks) {
+					callback(error, result);
+				}
 			}
-			inHandleResult--;
-		});
+		}
+		inHandleResult--;
 	}
 
 	clear() {

package/lib/util/LocConverter.js

@@ -29,17 +29,18 @@ class LocConverter {
 	get(pos) {
 		if (this.pos !== pos) {
 			if (this.pos < pos) {
-				const str = this._input.slice(this.pos, pos);
-				let i = str.lastIndexOf("\n");
-				if (i === -1) {
-					this.column += str.length;
-				} else {
-					this.column = str.length - i - 1;
-					this.line++;
-					while (i > 0 && (i = str.lastIndexOf("\n", i - 1)) !== -1) {
+				// Advance: delta-bounded scan of [this.pos, pos), allocation-free
+				// (unbounded index scans go quadratic on newline-free input).
+				const input = this._input;
+				let last = -1;
+				for (let j = this.pos; j < pos; j++) {
+					if (input.charCodeAt(j) === 10) {
 						this.line++;
+						last = j;
 					}
 				}
+				this.column =
+					last === -1 ? this.column + (pos - this.pos) : pos - last - 1;
 			} else {
 				// Retreat: count newlines crossed in (pos, this.pos), i.e.
 				// exclude the newline at `this.pos` itself. By convention a

package/lib/util/SetHelpers.js

@@ -41,7 +41,7 @@ const intersect = (sets) => {
  * @template T
  * @param {Set<T>} bigSet a Set which contains the original elements to compare against
  * @param {Set<T>} smallSet the set whose elements might be contained inside of bigSet
- * @returns {boolean} returns true if smallSet contains all elements inside of the bigSet
+ * @returns {boolean} returns true if bigSet contains all elements inside of smallSet
  */
 const isSubset = (bigSet, smallSet) => {
 	if (bigSet.size < smallSet.size) return false;