webpack 5.110.2 → 5.110.3

package/lib/dependencies/ContextDependencyTemplateAsRequireCall.js

@@ -22,11 +22,9 @@ class ContextDependencyTemplateAsRequireCall
 	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	apply(
-		dependency,
-		source,
-		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
-	) {
+	apply(dependency, source, templateContext) {
+		const { runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements } =
+			templateContext;
 		const dep = /** @type {ContextDependency} */ (dependency);
 		let moduleExports = runtimeTemplate.moduleExports({
 			module: moduleGraph.getModule(dep),
@@ -49,8 +47,7 @@ class ContextDependencyTemplateAsRequireCall
 						source.replace(rep.range[0], rep.range[1] - 1, rep.value);
 					}
 				}
-				source.replace(dep.valueRange[1], range[1] - 1, ")");
-				source.replace(range[0], dep.valueRange[0] - 1, `${moduleExports}(`);
+				this.replaceCall(dep, source, moduleExports, templateContext);
 			} else {
 				source.replace(range[0], range[1] - 1, moduleExports);
 			}
@@ -58,6 +55,22 @@ class ContextDependencyTemplateAsRequireCall
 			source.replace(range[0], range[1] - 1, moduleExports);
 		}
 	}
+
+	/**
+	 * Rewrites the call around its request, dropping anything the original one
+	 * carried after it. Overridden where a later argument must be kept.
+	 * @param {ContextDependency} dep the dependency
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {string} moduleExports the expression the request is passed to
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	replaceCall(dep, source, moduleExports, templateContext) {
+		const range = /** @type {Range} */ (dep.range);
+		const valueRange = /** @type {Range} */ (dep.valueRange);
+		source.replace(valueRange[1], range[1] - 1, ")");
+		source.replace(range[0], valueRange[0] - 1, `${moduleExports}(`);
+	}
 }
 
 module.exports = ContextDependencyTemplateAsRequireCall;

package/lib/dependencies/HarmonyExportImportedSpecifierDependency.js

@@ -237,12 +237,28 @@ const isStarReexportBackToParent = (moduleGraph, exportInfo, parentModule) => {
 	}
 };
 
+/**
+ * Two `export *` sources are ambiguous for a name when they resolve to
+ * different bindings; a diamond re-export of the same binding is not.
+ * @param {ModuleGraph} moduleGraph module graph
+ * @param {InstanceType<ExportInfo>} previous export info of the star source that first provided the name
+ * @param {InstanceType<ExportInfo>} exportInfo export info of a later star source providing the same name
+ * @returns {boolean} true when the two sources provide different bindings
+ */
+const isAmbiguousWith = (moduleGraph, previous, exportInfo) => {
+	const previousBinding = previous.getTerminalBinding(moduleGraph);
+	if (!previousBinding) return false;
+	const binding = exportInfo.getTerminalBinding(moduleGraph);
+	if (!binding) return false;
+	return previousBinding !== binding;
+};
+
 /**
  * Determine export assignments.
  * @param {ModuleGraph} moduleGraph module graph
  * @param {HarmonyExportImportedSpecifierDependency[]} dependencies dependencies
  * @param {HarmonyExportImportedSpecifierDependency=} additionalDependency additional dependency
- * @returns {{ names: ExportInfoName[], dependencyIndices: DependencyIndices }} result
+ * @returns {{ names: ExportInfoName[], dependencyIndices: DependencyIndices, conflicting: Set<ExportInfoName> | undefined }} result
  */
 const determineExportAssignments = (
 	moduleGraph,
@@ -253,6 +269,10 @@ const determineExportAssignments = (
 	const names = new Set();
 	/** @type {DependencyIndices} */
 	const dependencyIndices = [];
+	/** @type {Map<ExportInfoName, InstanceType<ExportInfo>>} */
+	const firstProvider = new Map();
+	/** @type {Set<ExportInfoName> | undefined} */
+	let conflicting;
 
 	if (additionalDependency) {
 		dependencies = [...dependencies, additionalDependency];
@@ -270,24 +290,42 @@ const determineExportAssignments = (
 		if (otherImportedModule) {
 			const exportsInfo = moduleGraph.getExportsInfo(otherImportedModule);
 			for (const exportInfo of exportsInfo.exports) {
+				if (exportInfo.provided !== true || exportInfo.name === "default") {
+					continue;
+				}
+				if (names.has(exportInfo.name)) {
+					const previous =
+						/** @type {InstanceType<ExportInfo>} */
+						(firstProvider.get(exportInfo.name));
+					if (
+						isAmbiguousWith(moduleGraph, previous, exportInfo) &&
+						// A cyclic contribution resolves to nothing, so it never competes
+						// with the binding a sibling `export *` provides.
+						!(
+							parentModule &&
+							isStarReexportBackToParent(moduleGraph, exportInfo, parentModule)
+						)
+					) {
+						if (conflicting === undefined) conflicting = new Set();
+						conflicting.add(exportInfo.name);
+					}
+					continue;
+				}
 				if (
-					exportInfo.provided === true &&
-					exportInfo.name !== "default" &&
-					!names.has(exportInfo.name) &&
-					!(
-						parentModule &&
-						isStarReexportBackToParent(moduleGraph, exportInfo, parentModule)
-					)
+					parentModule &&
+					isStarReexportBackToParent(moduleGraph, exportInfo, parentModule)
 				) {
-					names.add(exportInfo.name);
-					dependencyIndices[i] = names.size;
+					continue;
 				}
+				names.add(exportInfo.name);
+				firstProvider.set(exportInfo.name, exportInfo);
+				dependencyIndices[i] = names.size;
 			}
 		}
 	}
 	dependencyIndices.push(names.size);
 
-	return { names: [...names], dependencyIndices };
+	return { names: [...names], dependencyIndices, conflicting };
 };
 
 /**
@@ -666,6 +704,12 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 		/** @type {IgnoredExports} */
 		const ignoredExports = new Set(this.activeExports);
 		ignoredExports.add("default");
+		// An ambiguous name resolves to no binding at all, so no `export *` in this
+		// module may contribute it — not even the first one.
+		const conflicting = this._getConflictingStarExportNames(moduleGraph);
+		if (conflicting !== undefined) {
+			for (const name of conflicting) ignoredExports.add(name);
+		}
 
 		/** @type {Hidden | undefined} */
 		let hiddenExports;
@@ -871,6 +915,21 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 		}
 	}
 
+	/**
+	 * Names this module's `export *` sources provide with conflicting bindings.
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {Set<ExportInfoName> | undefined} ambiguous names, or nothing when there are none
+	 */
+	_getConflictingStarExportNames(moduleGraph) {
+		// Every `export *` carries the module's full star list; a lone one has
+		// nothing to be ambiguous with, so skip the walk.
+		if (!this.allStarExports) return;
+		const { dependencies } = this.allStarExports;
+		if (dependencies.length < 2) return;
+		return moduleGraph.cached(determineExportAssignments, dependencies)
+			.conflicting;
+	}
+
 	/**
 	 * Discover active exports from other star exports.
 	 * @param {ModuleGraph} moduleGraph the module graph
@@ -1072,7 +1131,10 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 	 */
 	getWarnings(moduleGraph) {
 		const exportsPresence = this._getEffectiveExportPresenceLevel(moduleGraph);
-		const circular = this._getCircularReexportWarnings(moduleGraph);
+		const circular =
+			this._getCircularReexportPresenceLevel() === ExportPresenceModes.WARN
+				? this._getCircularReexportErrors(moduleGraph)
+				: undefined;
 		if (exportsPresence === ExportPresenceModes.WARN) {
 			const errors = this._getErrors(moduleGraph);
 			if (!circular) return errors;
@@ -1082,12 +1144,23 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 	}
 
 	/**
-	 * Returns warnings for a name resolving through a circular reexport chain,
-	 * off the export-presence path so a strict harmony module warns, not fails.
+	 * Reporting level for a circular reexport chain. It skips the promotion to
+	 * an error that AUTO gives a strict harmony module — a cycle warns by
+	 * default — but an explicit setting still says whether and how to report.
+	 * @returns {ExportPresenceMode} effective mode
+	 */
+	_getCircularReexportPresenceLevel() {
+		return this.exportPresenceMode === ExportPresenceModes.AUTO
+			? ExportPresenceModes.WARN
+			: this.exportPresenceMode;
+	}
+
+	/**
+	 * Returns errors for a name resolving through a circular reexport chain.
 	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {WebpackError[] | undefined} warnings
+	 * @returns {WebpackError[] | undefined} errors
 	 */
-	_getCircularReexportWarnings(moduleGraph) {
+	_getCircularReexportErrors(moduleGraph) {
 		const ids = this.getIds(moduleGraph);
 		if (ids.length === 0 || !this.name) return;
 		const parentModule = /** @type {Module} */ (
@@ -1115,10 +1188,18 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 	 */
 	getErrors(moduleGraph) {
 		const exportsPresence = this._getEffectiveExportPresenceLevel(moduleGraph);
-		if (exportsPresence === ExportPresenceModes.ERROR) {
-			return this._getErrors(moduleGraph);
+		const errors =
+			exportsPresence === ExportPresenceModes.ERROR
+				? this._getErrors(moduleGraph)
+				: null;
+		if (
+			this._getCircularReexportPresenceLevel() !== ExportPresenceModes.ERROR
+		) {
+			return errors;
 		}
-		return null;
+		const circular = this._getCircularReexportErrors(moduleGraph);
+		if (!circular) return errors;
+		return errors ? [...errors, ...circular] : circular;
 	}
 
 	/**

package/lib/dependencies/HarmonyImportDependency.js

@@ -11,11 +11,14 @@ const InitFragment = require("../InitFragment");
 const Template = require("../Template");
 const AwaitDependenciesInitFragment = require("../async-modules/AwaitDependenciesInitFragment");
 const isGeneratorLowered = require("../async-modules/isGeneratorLowered");
+const memoize = require("../util/memoize");
 const { filterRuntime, mergeRuntime } = require("../util/runtime");
 const HarmonyLinkingError = require("./HarmonyLinkingError");
 const { ImportPhase, ImportPhaseUtils } = require("./ImportPhase");
 const ModuleDependency = require("./ModuleDependency");
 
+const getExternalModule = memoize(() => require("../ExternalModule"));
+
 /** @import { ReplaceSource } from "webpack-sources" */
 /**
  * @import {
@@ -97,6 +100,31 @@ const getNonOptionalPart = (members, membersOptionals) => {
 
 /** @typedef {string[]} Ids */
 
+/**
+ * Export names a lazy barrel still defers, so they are missing from its provided
+ * exports without being absent from the module.
+ * @param {Module} module the imported module
+ * @returns {Set<string> | true | undefined} deferred names, true when a deferred star re-export may provide any name, undefined when none
+ */
+const getDeferredExports = (module) => {
+	const factoryMeta = module.factoryMeta;
+	if (factoryMeta === undefined || !factoryMeta.sideEffectFree) return;
+	/** @type {Set<string> | undefined} */
+	let names;
+	for (const dep of module.dependencies) {
+		// TODO remove in webpack 6
+		// These may be missing on custom dependency types not extending the base Dependency
+		if (!("getLazyUntil" in dep) || !("isLazy" in dep)) continue;
+		if (!dep.isLazy()) continue;
+		const until = dep.getLazyUntil();
+		if (until === Dependency.LAZY_UNTIL_FALLBACK) return true;
+		if (until !== Dependency.LAZY_UNTIL_ID) continue;
+		if (names === undefined) names = new Set();
+		names.add(/** @type {string} */ (dep.getLazyName()));
+	}
+	return names;
+};
+
 class HarmonyImportDependency extends ModuleDependency {
 	/**
 	 * Creates an instance of HarmonyImportDependency.
@@ -185,9 +213,14 @@ class HarmonyImportDependency extends ModuleDependency {
 		const importedModule = /** @type {Module} */ (moduleGraph.getModule(this));
 		const meta = moduleGraph.getMeta(module);
 
+		// An async external is a promise webpack awaits, not a module record with
+		// an evaluating state, so deferring its namespace would never throw.
 		const isDeferred =
 			ImportPhaseUtils.isDefer(this.phase) &&
-			!(/** @type {BuildMeta} */ (importedModule.buildMeta).async);
+			!(
+				/** @type {BuildMeta} */ (importedModule.buildMeta).async &&
+				importedModule instanceof getExternalModule()
+			);
 
 		const metaKey = isDeferred ? "deferredImportVarMap" : "importVarMap";
 		let importVarMap = meta[metaKey];
@@ -283,48 +316,63 @@ class HarmonyImportDependency extends ModuleDependency {
 				(exportsType !== "default-with-named" || ids[0] !== "default") &&
 				moduleGraph.isExportProvided(importedModule, ids) === false
 			) {
-				// We are sure that it's not provided
-
-				// Try to provide detailed info in the error message
-				let pos = 0;
-				let exportsInfo = moduleGraph.getExportsInfo(importedModule);
-				while (pos < ids.length && exportsInfo) {
-					const id = ids[pos++];
-					const exportInfo = exportsInfo.getReadOnlyExportInfo(id);
-					if (exportInfo.provided === false) {
-						// We are sure that it's not provided
-						const providedExports = exportsInfo.getProvidedExports();
-						const moreInfo = !Array.isArray(providedExports)
-							? " (possible exports unknown)"
-							: providedExports.length === 0
-								? " (module has no exports)"
-								: ` (possible exports: ${providedExports.join(", ")})`;
-						return [
-							new HarmonyLinkingError(
-								`export ${ids
-									.slice(0, pos)
-									.map((id) => `'${id}'`)
-									.join(".")} ${additionalMessage} was not found in '${
-									this.userRequest
-								}'${moreInfo}`
-							)
-						];
+				const deferredExports = getDeferredExports(importedModule);
+
+				if (
+					deferredExports !== true &&
+					(deferredExports === undefined || !deferredExports.has(ids[0]))
+				) {
+					// We are sure that it's not provided
+
+					// Try to provide detailed info in the error message
+					let pos = 0;
+					let exportsInfo = moduleGraph.getExportsInfo(importedModule);
+					while (pos < ids.length && exportsInfo) {
+						const id = ids[pos++];
+						const exportInfo = exportsInfo.getReadOnlyExportInfo(id);
+						if (exportInfo.provided === false) {
+							// We are sure that it's not provided
+							let providedExports = exportsInfo.getProvidedExports();
+							// only the first level names the imported module itself
+							if (
+								pos === 1 &&
+								deferredExports !== undefined &&
+								Array.isArray(providedExports)
+							) {
+								providedExports = [...providedExports, ...deferredExports];
+							}
+							const moreInfo = !Array.isArray(providedExports)
+								? " (possible exports unknown)"
+								: providedExports.length === 0
+									? " (module has no exports)"
+									: ` (possible exports: ${providedExports.join(", ")})`;
+							return [
+								new HarmonyLinkingError(
+									`export ${ids
+										.slice(0, pos)
+										.map((id) => `'${id}'`)
+										.join(".")} ${additionalMessage} was not found in '${
+										this.userRequest
+									}'${moreInfo}`
+								)
+							];
+						}
+						exportsInfo =
+							/** @type {ExportsInfo} */
+							(exportInfo.getNestedExportsInfo());
 					}
-					exportsInfo =
-						/** @type {ExportsInfo} */
-						(exportInfo.getNestedExportsInfo());
-				}
 
-				// General error message
-				return [
-					new HarmonyLinkingError(
-						`export ${ids
-							.map((id) => `'${id}'`)
-							.join(".")} ${additionalMessage} was not found in '${
-							this.userRequest
-						}'`
-					)
-				];
+					// General error message
+					return [
+						new HarmonyLinkingError(
+							`export ${ids
+								.map((id) => `'${id}'`)
+								.join(".")} ${additionalMessage} was not found in '${
+								this.userRequest
+							}'`
+						)
+					];
+				}
 			}
 		}
 		switch (exportsType) {
@@ -468,8 +516,13 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 		}
 
 		const importStatement = dep.getImportStatement(false, templateContext);
+		// A module deferring itself is already evaluating: awaiting it would probe
+		// the deferred namespace and force the evaluation it must not trigger.
+		const isSelfDeferred =
+			ImportPhaseUtils.isDefer(dep.phase) && referencedModule === module;
 		if (
 			referencedModule &&
+			!isSelfDeferred &&
 			templateContext.moduleGraph.isAsync(referencedModule)
 		) {
 			templateContext.initFragments.push(

package/lib/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const ImportedBindingAssignmentError = require("../errors/ImportedBindingAssignmentError");
 const WebpackError = require("../errors/WebpackError");
 const getParserHooks = require("../hmr/parserHooks");
 const {
@@ -393,11 +394,20 @@ class HarmonyImportDependencyParserPlugin {
 		);
 		// Concatenation would turn the binding into a plain local, losing the
 		// getter-only property whose write throws.
-		parser.hooks.assign.for(harmonySpecifierTag).tap(PLUGIN_NAME, () => {
-			markUsed(/** @type {HarmonySettings} */ (parser.currentTagData));
+		parser.hooks.assign.for(harmonySpecifierTag).tap(PLUGIN_NAME, (expr) => {
+			const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
+			markUsed(settings);
 			/** @type {JavascriptModuleBuildInfo} */
 			(parser.state.module.buildInfo).moduleConcatenationBailout =
 				"assignment to an imported binding";
+			// A named import is written through the namespace's getter-only
+			// property, which throws on its own. A namespace one is the binding
+			// itself, and nothing webpack can emit for it throws, so report it.
+			if (settings.ids.length === 0) {
+				const error = new ImportedBindingAssignmentError(settings.name);
+				error.loc = parser.getLocation(expr);
+				parser.state.module.addError(error);
+			}
 		});
 		parser.hooks.expression
 			.for(harmonySpecifierTag)

package/lib/dependencies/HtmlEntryDependency.js

@@ -194,7 +194,12 @@ const getEntrypointChunksInLoadOrder = (entrypoint) => {
 	const chunksLoadedByAncestorTags = new Set();
 	/** @type {Set<import("../ChunkGroup")>} */
 	const visitedGroups = new Set();
-	const walk = (/** @type {import("../ChunkGroup")} */ group) => {
+	/**
+	 * Collects the chunks an ancestor entry's own tags already load.
+	 * @param {import("../ChunkGroup")} group chunk group to walk up from
+	 * @returns {void}
+	 */
+	const walk = (group) => {
 		if (visitedGroups.has(group)) return;
 		visitedGroups.add(group);
 		for (const parent of group.parentsIterable) {
@@ -220,7 +225,12 @@ const getEntrypointChunksInLoadOrder = (entrypoint) => {
 	const ordered = [];
 	/** @type {Set<Chunk>} */
 	const seen = new Set();
-	const push = (/** @type {Chunk | null | undefined} */ chunk) => {
+	/**
+	 * Appends a chunk once, skipping the ones an ancestor entry already loads.
+	 * @param {Chunk | null | undefined} chunk chunk to append
+	 * @returns {void}
+	 */
+	const push = (chunk) => {
 		if (!chunk || seen.has(chunk) || chunk === entryChunk) return;
 		if (chunksLoadedByAncestorTags.has(chunk)) return;
 		seen.add(chunk);

package/lib/dependencies/ImportContextDependency.js

@@ -8,11 +8,13 @@
 const makeSerializable = require("../util/makeSerializable");
 const ContextDependency = require("./ContextDependency");
 const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTemplateAsRequireCall");
+const importOptionsCheck = require("./importOptionsCheck");
 
 /** @import { Range } from "../javascript/JavascriptParser" */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Range]>} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Range]>} ObjectSerializerContext */
+/** @import { ObjectDeserializerContext, ObjectSerializerContext } from "../serialization/ObjectMiddleware" */
 /** @import { ContextDependencyOptions } from "./ContextDependency" */
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
 
 class ImportContextDependency extends ContextDependency {
 	/**
@@ -26,6 +28,8 @@ class ImportContextDependency extends ContextDependency {
 
 		this.range = range;
 		this.valueRange = valueRange;
+		/** @type {Range | undefined} */
+		this.optionsRange = undefined;
 	}
 
 	get type() {
@@ -56,6 +60,7 @@ class ImportContextDependency extends ContextDependency {
 	 */
 	serialize(context) {
 		context.write(this.valueRange);
+		context.write(this.optionsRange);
 
 		super.serialize(context);
 	}
@@ -66,6 +71,7 @@ class ImportContextDependency extends ContextDependency {
 	 */
 	deserialize(context) {
 		this.valueRange = context.read();
+		this.optionsRange = context.read();
 
 		super.deserialize(context.rest);
 	}
@@ -76,6 +82,40 @@ makeSerializable(
 	"webpack/lib/dependencies/ImportContextDependency"
 );
 
-ImportContextDependency.Template = ContextDependencyTemplateAsRequireCall;
+ImportContextDependency.Template = class ImportContextDependencyTemplate extends (
+	ContextDependencyTemplateAsRequireCall
+) {
+	/**
+	 * Rewrites the call around its request, dropping anything the original one
+	 * carried after it. Overridden where a later argument must be kept.
+	 * @param {ContextDependency} dep the dependency
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {string} moduleExports the expression the request is passed to
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	replaceCall(dep, source, moduleExports, templateContext) {
+		const optionsRange = /** @type {ImportContextDependency} */ (dep)
+			.optionsRange;
+		if (optionsRange === undefined) {
+			super.replaceCall(dep, source, moduleExports, templateContext);
+			return;
+		}
+		// Request then options, in that order; their own source is kept so
+		// nested dependencies in them still get their replacements.
+		const range = /** @type {Range} */ (dep.range);
+		const valueRange = /** @type {Range} */ (dep.valueRange);
+		const check = importOptionsCheck(
+			templateContext.runtimeTemplate,
+			["r", "o"],
+			`${moduleExports}(r)`
+		);
+		source.replace(range[0], valueRange[0] - 1, `(${check})(`);
+		// The options range excludes any parentheses the source had, so a comma
+		// expression would otherwise split into arguments of its own.
+		source.replace(valueRange[1], optionsRange[0] - 1, ", (");
+		source.replace(optionsRange[1], range[1] - 1, "))");
+	}
+};
 
 module.exports = ImportContextDependency;

package/lib/dependencies/ImportDependency.js

@@ -6,11 +6,11 @@
 "use strict";
 
 const Dependency = require("../Dependency");
-const Template = require("../Template");
 const makeSerializable = require("../util/makeSerializable");
 const HarmonyImportGuard = require("./HarmonyImportGuard");
 const { ImportPhaseUtils } = require("./ImportPhase");
 const ModuleDependency = require("./ModuleDependency");
+const importOptionsCheck = require("./importOptionsCheck");
 
 /** @import { ReplaceSource } from "webpack-sources" */
 /** @import AsyncDependenciesBlock from "../AsyncDependenciesBlock" */
@@ -226,35 +226,14 @@ ImportDependency.Template = class ImportDependencyTemplate extends (
 		}
 
 		// A non-static second argument must still be evaluated (for its side
-		// effects and evaluation order) and validated per spec. Keep it in place
-		// and wrap it in an inline validator that mirrors the runtime checks of
-		// the spec's `import(specifier, options)` evaluation.
+		// effects and evaluation order) and checked per spec, so keep it in place
+		// and wrap it.
 		if (dep.optionsRange) {
-			const validator = runtimeTemplate.basicFunction("o", [
-				"try {",
-				Template.indent([
-					"if (o !== undefined) {",
-					Template.indent([
-						'if ((typeof o !== "object" && typeof o !== "function") || o === null) throw new TypeError("The second argument to import() must be an object");',
-						'var a = o["with"];',
-						"if (a !== undefined) {",
-						Template.indent([
-							'if ((typeof a !== "object" && typeof a !== "function") || a === null) throw new TypeError("The \'with\' option must be an object");',
-							"for (var k = Object.keys(a), i = 0; i < k.length; i++) {",
-							Template.indent([
-								'if (typeof a[k[i]] !== "string") throw new TypeError("Import attribute values must be strings");'
-							]),
-							"}"
-						]),
-						"}"
-					]),
-					"}"
-				]),
-				"} catch (e) { return Promise.reject(e); }",
-				`return ${content};`
-			]);
-			source.replace(dep.range[0], dep.optionsRange[0] - 1, `(${validator})(`);
-			source.replace(dep.optionsRange[1], dep.range[1] - 1, ")");
+			const check = importOptionsCheck(runtimeTemplate, ["o"], content);
+			// The options range excludes any parentheses the source had, so a
+			// comma expression would otherwise split into arguments of its own.
+			source.replace(dep.range[0], dep.optionsRange[0] - 1, `(${check})((`);
+			source.replace(dep.optionsRange[1], dep.range[1] - 1, "))");
 			return;
 		}
 

package/lib/dependencies/ImportParserPlugin.js

@@ -209,20 +209,18 @@ const isStaticStringAttributes = (node) => {
 				: 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;
-				}
+		// Any other key is an expression webpack cannot account for, and its
+		// value still evaluates, so the argument has to stay.
+		if (keyName !== "with" && keyName !== "assert") return false;
+		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;
 			}
 		}
 	}
@@ -676,6 +674,18 @@ class ImportParserPlugin {
 					parser
 				);
 				if (!dep) return;
+				// The context module ignores the options argument, but the spec
+				// evaluates it, so anything but a static attributes object stays.
+				const optionsNode = expr.options;
+				if (
+					optionsNode &&
+					optionsNode.range &&
+					!isStaticStringAttributes(optionsNode)
+				) {
+					/** @type {ImportContextDependency} */ (dep).optionsRange =
+						/** @type {Range} */ (optionsNode.range);
+					parser.walkExpression(optionsNode);
+				}
 				dep.loc = parser.getLocation(expr);
 				dep.optional = Boolean(parser.scope.inTry);
 				parser.state.current.addDependency(dep);