webpack 5.108.3 → 5.109.0

package/lib/dependencies/ImportMetaResolveDependency.js

@@ -0,0 +1,90 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const makeSerializable = require("../util/makeSerializable");
+const ModuleDependency = require("./ModuleDependency");
+const URLDependency = require("./URLDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
+// `import.meta.resolve(specifier)` is the string form of
+// `new URL(specifier, import.meta.url)`, so it reuses the URL asset pipeline
+// but renders to the resolved URL string (`.href`) over the whole call.
+class ImportMetaResolveDependency extends URLDependency {
+	get type() {
+		return "import.meta.resolve()";
+	}
+}
+
+ImportMetaResolveDependency.Template = class ImportMetaResolveDependencyTemplate extends (
+	ModuleDependency.Template
+) {
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, templateContext) {
+		const {
+			chunkGraph,
+			moduleGraph,
+			runtimeRequirements,
+			runtimeTemplate,
+			runtime
+		} = templateContext;
+		const dep = /** @type {ImportMetaResolveDependency} */ (dependency);
+		const connection = moduleGraph.getConnection(dep);
+		// Skip rendering the dependency when it is conditional and inactive.
+		if (connection && !connection.isTargetActive(runtime)) {
+			source.replace(
+				dep.outerRange[0],
+				dep.outerRange[1] - 1,
+				"/* unused asset import */ undefined"
+			);
+			return;
+		}
+
+		runtimeRequirements.add(RuntimeGlobals.require);
+
+		const moduleRaw = runtimeTemplate.moduleRaw({
+			chunkGraph,
+			module: moduleGraph.getModule(dep),
+			request: dep.request,
+			runtimeRequirements,
+			weak: false
+		});
+
+		if (dep.relative) {
+			runtimeRequirements.add(RuntimeGlobals.relativeUrl);
+			source.replace(
+				dep.outerRange[0],
+				dep.outerRange[1] - 1,
+				`(new ${RuntimeGlobals.relativeUrl}(/* asset import */ ${moduleRaw})).href`
+			);
+		} else {
+			runtimeRequirements.add(RuntimeGlobals.baseURI);
+			source.replace(
+				dep.outerRange[0],
+				dep.outerRange[1] - 1,
+				`(new URL(/* asset import */ ${moduleRaw}, ${RuntimeGlobals.baseURI})).href`
+			);
+		}
+	}
+};
+
+makeSerializable(
+	ImportMetaResolveDependency,
+	"webpack/lib/dependencies/ImportMetaResolveDependency"
+);
+
+module.exports = ImportMetaResolveDependency;

package/lib/dependencies/ImportParserPlugin.js

@@ -174,6 +174,47 @@ const exportsFromEnumerable = (enumerable) =>
 
 const PLUGIN_NAME = "ImportParserPlugin";
 
+/**
+ * Whether an `import()` second argument is a fully static attributes object
+ * (every `with`/`assert` value is a string literal). Only then can webpack use
+ * the attributes at build time; otherwise the argument must be evaluated and
+ * validated at runtime per spec.
+ * @param {import("estree").Expression | null | undefined} node the second-argument AST node
+ * @returns {boolean} true if statically extractable
+ */
+const isStaticStringAttributes = (node) => {
+	if (!node || node.type !== "ObjectExpression") return false;
+	for (const prop of node.properties) {
+		if (prop.type !== "Property" || prop.kind !== "init" || prop.computed) {
+			return false;
+		}
+		const key = prop.key;
+		const keyName =
+			key.type === "Identifier"
+				? key.name
+				: key.type === "Literal"
+					? key.value
+					: undefined;
+		if (keyName === "with" || keyName === "assert") {
+			const value = prop.value;
+			if (value.type !== "ObjectExpression") return false;
+			for (const attr of value.properties) {
+				if (attr.type !== "Property" || attr.kind !== "init" || attr.computed) {
+					return false;
+				}
+				const attrValue = attr.value;
+				if (
+					attrValue.type !== "Literal" ||
+					typeof attrValue.value !== "string"
+				) {
+					return false;
+				}
+			}
+		}
+	}
+	return true;
+};
+
 class ImportParserPlugin {
 	/**
 	 * Creates an instance of ImportParserPlugin.
@@ -277,6 +318,7 @@ class ImportParserPlugin {
 
 			const {
 				dynamicImportPreload,
+				dynamicImportCssPreload,
 				dynamicImportPrefetch,
 				dynamicImportFetchPriority
 			} = this.options;
@@ -287,6 +329,13 @@ class ImportParserPlugin {
 				groupOptions.preloadOrder =
 					dynamicImportPreload === true ? 0 : dynamicImportPreload;
 			}
+			if (
+				dynamicImportCssPreload !== undefined &&
+				dynamicImportCssPreload !== false
+			) {
+				groupOptions.cssPreloadOrder =
+					dynamicImportCssPreload === true ? 0 : dynamicImportCssPreload;
+			}
 			if (
 				dynamicImportPrefetch !== undefined &&
 				dynamicImportPrefetch !== false
@@ -310,7 +359,7 @@ class ImportParserPlugin {
 					parser.state.module.addWarning(
 						new CommentCompilationWarning(
 							`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
-							/** @type {DependencyLocation} */ (comment.loc)
+							parser.getLocation(comment)
 						)
 					);
 				}
@@ -327,7 +376,7 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackIgnore\` expected a boolean, but received: ${importOptions.webpackIgnore}.`,
-								/** @type {DependencyLocation} */ (expr.loc)
+								parser.getLocation(expr)
 							)
 						);
 					} else if (importOptions.webpackIgnore) {
@@ -340,7 +389,7 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackChunkName\` expected a string, but received: ${importOptions.webpackChunkName}.`,
-								/** @type {DependencyLocation} */ (expr.loc)
+								parser.getLocation(expr)
 							)
 						);
 					} else {
@@ -352,7 +401,7 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackMode\` expected a string, but received: ${importOptions.webpackMode}.`,
-								/** @type {DependencyLocation} */ (expr.loc)
+								parser.getLocation(expr)
 							)
 						);
 					} else {
@@ -368,7 +417,7 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackPrefetch\` expected true or a number, but received: ${importOptions.webpackPrefetch}.`,
-								/** @type {DependencyLocation} */ (expr.loc)
+								parser.getLocation(expr)
 							)
 						);
 					}
@@ -382,7 +431,7 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackPreload\` expected true or a number, but received: ${importOptions.webpackPreload}.`,
-								/** @type {DependencyLocation} */ (expr.loc)
+								parser.getLocation(expr)
 							)
 						);
 					}
@@ -399,7 +448,7 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackFetchPriority\` expected true or "low", "high" or "auto", but received: ${importOptions.webpackFetchPriority}.`,
-								/** @type {DependencyLocation} */ (expr.loc)
+								parser.getLocation(expr)
 							)
 						);
 					}
@@ -412,7 +461,7 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackInclude\` expected a regular expression, but received: ${importOptions.webpackInclude}.`,
-								/** @type {DependencyLocation} */ (expr.loc)
+								parser.getLocation(expr)
 							)
 						);
 					} else {
@@ -427,7 +476,7 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackExclude\` expected a regular expression, but received: ${importOptions.webpackExclude}.`,
-								/** @type {DependencyLocation} */ (expr.loc)
+								parser.getLocation(expr)
 							)
 						);
 					} else {
@@ -435,19 +484,17 @@ class ImportParserPlugin {
 					}
 				}
 				if (importOptions.webpackExports !== undefined) {
-					if (
-						!(
-							typeof importOptions.webpackExports === "string" ||
-							(Array.isArray(importOptions.webpackExports) &&
-								importOptions.webpackExports.every(
-									(item) => typeof item === "string"
-								))
-						)
-					) {
+					if (!(
+						typeof importOptions.webpackExports === "string" ||
+						(Array.isArray(importOptions.webpackExports) &&
+							importOptions.webpackExports.every(
+								(item) => typeof item === "string"
+							))
+					)) {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackExports\` expected a string or an array of strings, but received: ${importOptions.webpackExports}.`,
-								/** @type {DependencyLocation} */ (expr.loc)
+								parser.getLocation(expr)
 							)
 						);
 					} else if (typeof importOptions.webpackExports === "string") {
@@ -466,7 +513,7 @@ class ImportParserPlugin {
 					parser.state.module.addWarning(
 						new UnsupportedFeatureWarning(
 							"`worker` entry option is not supported in `import()`, it only applies to workers (e.g. `new Worker(new URL(...))`).",
-							/** @type {DependencyLocation} */ (expr.loc)
+							parser.getLocation(expr)
 						)
 					);
 				}
@@ -481,7 +528,7 @@ class ImportParserPlugin {
 				parser.state.module.addWarning(
 					new UnsupportedFeatureWarning(
 						`\`webpackMode\` expected 'lazy', 'lazy-once', 'eager' or 'weak', but received: ${mode}.`,
-						/** @type {DependencyLocation} */ (expr.loc)
+						parser.getLocation(expr)
 					)
 				);
 				mode = "lazy";
@@ -502,7 +549,7 @@ class ImportParserPlugin {
 					parser.state.module.addWarning(
 						new UnsupportedFeatureWarning(
 							"You don't need `webpackExports` if the usage of dynamic import is statically analyse-able. You can safely remove the `webpackExports` magic comment.",
-							/** @type {DependencyLocation} */ (expr.loc)
+							parser.getLocation(expr)
 						)
 					);
 				}
@@ -554,17 +601,31 @@ class ImportParserPlugin {
 							...groupOptions,
 							name: chunkName
 						},
-						/** @type {DependencyLocation} */ (expr.loc),
+						parser.getLocation(expr),
 						param.string
 					);
+					// A second argument that isn't a statically extractable attributes
+					// object still has to be evaluated and validated at runtime, so
+					// drop the (unreliable) static attributes for it.
+					const optionsNode = expr.options;
+					const runtimeValidateOptions = Boolean(
+						optionsNode && !isStaticStringAttributes(optionsNode)
+					);
 					const dep = new ImportDependency(
 						/** @type {string} */ (param.string),
 						/** @type {Range} */ (expr.range),
 						exports,
 						phase,
-						attributes
+						runtimeValidateOptions ? undefined : attributes
 					);
-					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					if (runtimeValidateOptions && optionsNode && optionsNode.range) {
+						dep.optionsRange = /** @type {Range} */ (optionsNode.range);
+						// The options expression stays in the output, so walk it to
+						// register its variable references and keep them from being
+						// tree-shaken away.
+						parser.walkExpression(optionsNode);
+					}
+					dep.loc = parser.getLocation(expr);
 					dep.optional = Boolean(parser.scope.inTry);
 					depBlock.addDependency(dep);
 					parser.state.current.addBlock(depBlock);
@@ -601,7 +662,7 @@ class ImportParserPlugin {
 					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);
 			}

package/lib/dependencies/ImportPhase.js

@@ -103,15 +103,13 @@ function createGetImportPhase(enableDeferPhase, enableSourcePhase) {
 				if (!node.range) return null;
 				const { options, errors } = parser.parseCommentOptions(node.range);
 				if (errors) {
+					const CommentCompilationWarning = getCommentCompilationWarning();
 					for (const e of errors) {
 						const { comment } = e;
-						if (!comment.loc) continue;
-
-						const CommentCompilationWarning = getCommentCompilationWarning();
 						parser.state.module.addWarning(
 							new CommentCompilationWarning(
 								`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
-								comment.loc
+								parser.getLocation(comment)
 							)
 						);
 					}
@@ -134,13 +132,15 @@ function createGetImportPhase(enableDeferPhase, enableSourcePhase) {
 		if (enableDeferPhase && typeof options.webpackDefer !== "undefined") {
 			if (typeof webpackDefer === "boolean") {
 				return webpackDefer ? ImportPhase.Defer : phaseBySyntax;
-			} else if (node.loc) {
+			}
+			const loc = parser.getLocation(node);
+			if (loc) {
 				const CommentCompilationWarning = getCommentCompilationWarning();
 
 				parser.state.module.addWarning(
 					new CommentCompilationWarning(
 						"webpackDefer magic comment expected a boolean value.",
-						node.loc
+						loc
 					)
 				);
 			}
@@ -149,13 +149,15 @@ function createGetImportPhase(enableDeferPhase, enableSourcePhase) {
 		if (enableSourcePhase && typeof options.webpackSource !== "undefined") {
 			if (typeof webpackSource === "boolean") {
 				return webpackSource ? ImportPhase.Source : phaseBySyntax;
-			} else if (node.loc) {
+			}
+			const loc = parser.getLocation(node);
+			if (loc) {
 				const CommentCompilationWarning = getCommentCompilationWarning();
 
 				parser.state.module.addWarning(
 					new CommentCompilationWarning(
 						"webpackSource magic comment expected a boolean value.",
-						node.loc
+						loc
 					)
 				);
 			}

package/lib/dependencies/LoaderPlugin.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const NormalModule = require("../NormalModule");
+const { markNotCacheable } = require("../loaders/LoaderRunner");
 const LazySet = require("../util/LazySet");
 const LoaderDependency = require("./LoaderDependency");
 const LoaderImportDependency = require("./LoaderImportDependency");
@@ -237,6 +238,7 @@ class LoaderPlugin {
 											missingDependencies,
 											buildDependencies,
 											cacheable,
+											notCacheableReasons,
 											assets,
 											exports
 										} = /** @type {ExecuteModuleResult} */ (result);
@@ -252,7 +254,9 @@ class LoaderPlugin {
 										for (const d of buildDependencies) {
 											loaderContext.addBuildDependency(d);
 										}
-										if (cacheable === false) loaderContext.cacheable(false);
+										if (cacheable === false) {
+											markNotCacheable(loaderContext, notCacheableReasons);
+										}
 										for (const [name, { source, info }] of assets) {
 											const buildInfo =
 												/** @type {BuildInfo} */

package/lib/dependencies/RequireContextDependencyParserPlugin.js

@@ -59,7 +59,7 @@ module.exports = class RequireContextDependencyParserPlugin {
 						/** @type {Range} */
 						(expr.range)
 					);
-					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					dep.loc = parser.getLocation(expr);
 					dep.optional = Boolean(parser.scope.inTry);
 					parser.state.current.addDependency(dep);
 					return true;

package/lib/dependencies/RequireEnsureDependenciesBlockParserPlugin.js

@@ -76,8 +76,7 @@ module.exports = class RequireEnsureDependenciesBlockParserPlugin {
 
 					const depBlock = new RequireEnsureDependenciesBlock(
 						chunkName,
-						/** @type {DependencyLocation} */
-						(expr.loc)
+						parser.getLocation(expr)
 					);
 					const errorCallbackExists =
 						expr.arguments.length === 4 ||
@@ -88,7 +87,7 @@ module.exports = class RequireEnsureDependenciesBlockParserPlugin {
 						errorCallbackExists &&
 							/** @type {Range} */ (expr.arguments[2].range)
 					);
-					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					dep.loc = parser.getLocation(expr);
 					depBlock.addDependency(dep);
 					const old = parser.state.current;
 					parser.state.current = /** @type {EXPECTED_ANY} */ (depBlock);
@@ -100,9 +99,7 @@ module.exports = class RequireEnsureDependenciesBlockParserPlugin {
 									const ensureDependency = new RequireEnsureItemDependency(
 										/** @type {string} */ (ee.string)
 									);
-									ensureDependency.loc =
-										/** @type {DependencyLocation} */
-										(expr.loc);
+									ensureDependency.loc = parser.getLocation(expr);
 									depBlock.addDependency(ensureDependency);
 								} else {
 									failed = true;

package/lib/dependencies/RequireIncludeDependencyParserPlugin.js

@@ -43,10 +43,7 @@ module.exports = class RequireIncludeDependencyParserPlugin {
 
 			if (warn) {
 				parser.state.module.addWarning(
-					new RequireIncludeDeprecationWarning(
-						/** @type {DependencyLocation} */
-						(expr.loc)
-					)
+					new RequireIncludeDeprecationWarning(parser.getLocation(expr))
 				);
 			}
 
@@ -54,7 +51,7 @@ module.exports = class RequireIncludeDependencyParserPlugin {
 				/** @type {string} */ (param.string),
 				/** @type {Range} */ (expr.range)
 			);
-			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			dep.loc = parser.getLocation(expr);
 			parser.state.current.addDependency(dep);
 			return true;
 		});
@@ -63,9 +60,7 @@ module.exports = class RequireIncludeDependencyParserPlugin {
 			.tap(PLUGIN_NAME, (expr) => {
 				if (warn) {
 					parser.state.module.addWarning(
-						new RequireIncludeDeprecationWarning(
-							/** @type {DependencyLocation} */ (expr.loc)
-						)
+						new RequireIncludeDeprecationWarning(parser.getLocation(expr))
 					);
 				}
 				return evaluateToString("function")(expr);
@@ -73,9 +68,7 @@ module.exports = class RequireIncludeDependencyParserPlugin {
 		parser.hooks.typeof.for("require.include").tap(PLUGIN_NAME, (expr) => {
 			if (warn) {
 				parser.state.module.addWarning(
-					new RequireIncludeDeprecationWarning(
-						/** @type {DependencyLocation} */ (expr.loc)
-					)
+					new RequireIncludeDeprecationWarning(parser.getLocation(expr))
 				);
 			}
 			return toConstantDependency(parser, JSON.stringify("function"))(expr);

package/lib/dependencies/SystemPlugin.js

@@ -109,16 +109,14 @@ class SystemPlugin {
 							/** @type {Range} */ (expr.range),
 							[RuntimeGlobals.system]
 						);
-						dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+						dep.loc = parser.getLocation(expr);
 						parser.state.module.addPresentationalDependency(dep);
 						return true;
 					});
 
 					parser.hooks.call.for("System.import").tap(PLUGIN_NAME, (expr) => {
 						parser.state.module.addWarning(
-							new SystemImportDeprecationWarning(
-								/** @type {DependencyLocation} */ (expr.loc)
-							)
+							new SystemImportDeprecationWarning(parser.getLocation(expr))
 						);
 
 						return parser.hooks.importCall.call({

package/lib/dependencies/TopLevelAwaitDependency.js

@@ -0,0 +1,93 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const isGeneratorLowered = require("../async-modules/isGeneratorLowered");
+const makeSerializable = require("../util/makeSerializable");
+const NullDependency = require("./NullDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
+/**
+ * Marks a top-level `await` expression so it can be rewritten to `(yield …)`
+ * when the module is lowered to a generator (target without `async`/`await`).
+ */
+class TopLevelAwaitDependency extends NullDependency {
+	/**
+	 * @param {Range} range range of the whole `await` expression
+	 * @param {Range} argumentRange range of the awaited argument
+	 */
+	constructor(range, argumentRange) {
+		super();
+		/** @type {Range} */
+		this.range = range;
+		/** @type {Range} */
+		this.argumentRange = argumentRange;
+	}
+
+	/**
+	 * Serializes this instance into the provided serializer context.
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.range);
+		write(this.argumentRange);
+		super.serialize(context);
+	}
+
+	/**
+	 * Restores this instance from the provided deserializer context.
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.range = read();
+		this.argumentRange = read();
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	TopLevelAwaitDependency,
+	"webpack/lib/dependencies/TopLevelAwaitDependency"
+);
+
+TopLevelAwaitDependency.Template = class TopLevelAwaitDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, { module, moduleGraph, runtimeTemplate }) {
+		// Only rewrite when the body is a generator (no `async`/`await`, but
+		// generators). `await` and `yield` differ in precedence, so wrap the
+		// whole expression: `await X` -> `(yield X)`.
+		if (
+			!isGeneratorLowered(
+				/** @type {Module} */ (module),
+				moduleGraph,
+				runtimeTemplate
+			)
+		) {
+			return;
+		}
+		const dep = /** @type {TopLevelAwaitDependency} */ (dependency);
+		source.replace(dep.range[0], dep.argumentRange[0] - 1, "(yield ");
+		source.insert(dep.argumentRange[1], ")");
+	}
+};
+
+module.exports = TopLevelAwaitDependency;