webpack 5.110.2 → 5.111.0

package/lib/config/defaults.js

@@ -179,6 +179,7 @@ const {
  * portableRecords: NonNullable<Optimization["portableRecords"]>,
  * realContentHash: NonNullable<Optimization["realContentHash"]>,
  * minimize: NonNullable<Optimization["minimize"]>,
+ * minimizeOptions: NonNullable<Optimization["minimizeOptions"]>,
  * minimizer: NonNullable<Exclude<Optimization["minimizer"], "...">>,
  * nodeEnv: NonNullable<Optimization["nodeEnv"]>,
  * }} OptimizationNormalizedWithDefaults
@@ -302,6 +303,15 @@ const A = (obj, prop, factory) => {
 	}
 };
 
+/**
+ * Whether the library type emits an ECMAScript module, which only `output.module`
+ * output can carry — every other type is written into a script.
+ * @param {LibraryType | undefined} type library type
+ * @returns {boolean} true, when the type is only emitted as an ECMAScript module
+ */
+const isModuleLibraryType = (type) =>
+	type === "module" || type === "modern-module";
+
 /**
  * Apply webpack options base defaults.
  * @param {WebpackOptionsNormalized} options options to be modified
@@ -363,7 +373,6 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 	applyExperimentsDefaults(options.experiments, {
 		production,
 		development,
-		targetProperties,
 		rules: options.module.rules
 	});
 
@@ -407,9 +416,6 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 			(typeof target === "string" && target.startsWith("browserslist")) ||
 			(Array.isArray(target) &&
 				target.some((target) => target.startsWith("browserslist"))),
-		outputModule:
-			/** @type {NonNullable<ExperimentsNormalized["outputModule"]>} */
-			(options.experiments.outputModule),
 		development,
 		entry: options.entry,
 		futureDefaults,
@@ -422,9 +428,7 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 	// is read by another bundler, where an eval wrapper hides `import.meta` from it.
 	const noDevSourceMap = /** @type {LibraryType[]} */ (
 		options.output.enabledLibraryTypes
-	).some(
-		(type) => futureDefaults || type === "module" || type === "modern-module"
-	);
+	).some((type) => futureDefaults || isModuleLibraryType(type));
 
 	F(
 		options,
@@ -629,13 +633,12 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
  * @param {object} options options
  * @param {boolean} options.production is production
  * @param {boolean} options.development is development mode
- * @param {TargetProperties | false} options.targetProperties target properties
  * @param {RuleSetRules} options.rules user `module.rules`, used to resolve the css/html/asyncWebAssembly/typescript "auto" defaults
  * @returns {void}
  */
 const applyExperimentsDefaults = (
 	experiments,
-	{ production, development, targetProperties, rules }
+	{ production, development, rules }
 ) => {
 	D(experiments, "futureDefaults", false);
 	D(experiments, "backCompat", !experiments.futureDefaults);
@@ -646,23 +649,6 @@ const applyExperimentsDefaults = (
 		"asyncWebAssembly",
 		experiments.futureDefaults ? true : "auto"
 	);
-	// the universal target (web + node, neither specific) only works as ESM —
-	// unless the target cannot read one, which no output format can repair, so
-	// leave `output.chunkFormat` to say so rather than emitting a module the
-	// target has already reported it will not load
-	const universal =
-		Boolean(targetProperties) &&
-		/** @type {TargetProperties} */ (targetProperties).node === null &&
-		/** @type {TargetProperties} */ (targetProperties).web === null &&
-		/** @type {TargetProperties} */ (targetProperties).module !== false;
-	// the deno and bun targets only emit ECMAScript modules
-	const deno =
-		Boolean(targetProperties) &&
-		/** @type {TargetProperties} */ (targetProperties).deno === true;
-	const bun =
-		Boolean(targetProperties) &&
-		/** @type {TargetProperties} */ (targetProperties).bun === true;
-	D(experiments, "outputModule", universal || deno || bun);
 	D(experiments, "lazyCompilation", undefined);
 	D(experiments, "buildHttp", undefined);
 	D(experiments, "cacheUnaffected", experiments.futureDefaults);
@@ -918,6 +904,7 @@ const applyJavascriptParserOptionsDefaults = (
 	D(parserOptions, "wrappedContextRecursive", true);
 	D(parserOptions, "wrappedContextCritical", false);
 	D(parserOptions, "strictThisContextOnImports", false);
+	D(parserOptions, "specNamespaceObject", false);
 	D(parserOptions, "importMeta", outputModule ? "preserve-unknown" : true);
 	D(parserOptions, "dynamicImportMode", "lazy");
 	D(parserOptions, "dynamicImportPrefetch", false);
@@ -1432,8 +1419,10 @@ const applyModuleDefaults = (
 				type: HTML_MODULE_TYPE,
 				resolve
 			});
+			// Exactly `text/html` — a string condition matches by prefix, which
+			// would make a `data:text/htmlx,` module (JavaScript) a page.
 			rules.push({
-				mimetype: "text/html",
+				mimetype: /^text\/html$/i,
 				type: HTML_MODULE_TYPE,
 				resolve
 			});
@@ -1592,7 +1581,6 @@ const applyModuleDefaults = (
  * @param {string} options.context context
  * @param {TargetProperties | false} options.targetProperties target properties
  * @param {boolean} options.isAffectedByBrowserslist is affected by browserslist
- * @param {boolean} options.outputModule is outputModule experiment enabled
  * @param {boolean} options.development is development mode
  * @param {Entry} options.entry entry option
  * @param {boolean} options.futureDefaults is future defaults enabled
@@ -1605,7 +1593,6 @@ const applyOutputDefaults = (
 		context,
 		targetProperties: tp,
 		isAffectedByBrowserslist,
-		outputModule,
 		development,
 		entry,
 		futureDefaults,
@@ -1661,7 +1648,65 @@ const applyOutputDefaults = (
 		}
 	});
 
-	F(output, "module", () => Boolean(outputModule));
+	/**
+	 * Processes the provided fn.
+	 * @param {(entryDescription: EntryDescription) => void} fn iterator
+	 * @returns {void}
+	 */
+	const forEachEntry = (fn) => {
+		for (const name of Object.keys(entry)) {
+			fn(/** @type {{ [k: string]: EntryDescription }} */ (entry)[name]);
+		}
+	};
+
+	/**
+	 * Every library type the configuration states, wherever it was declared.
+	 * @returns {LibraryType[]} the declared library types
+	 */
+	const declaredLibraryTypes = () => {
+		/** @type {LibraryType[]} */
+		const types = [];
+		if (output.library && output.library.type) types.push(output.library.type);
+		// A plugin (`ModuleFederationPlugin`) pushed its type here before the defaults;
+		// `"..."` is the extend placeholder `A` resolves, never a type of its own.
+		if (output.enabledLibraryTypes) {
+			for (const type of output.enabledLibraryTypes) {
+				if (type !== "...") types.push(type);
+			}
+		}
+		forEachEntry((desc) => {
+			if (desc.library && desc.library.type) types.push(desc.library.type);
+		});
+		return types;
+	};
+
+	const libraryTypes = declaredLibraryTypes();
+
+	// A library type that is an ECMAScript module is another spelling of
+	// `output.module`, so it turns it on rather than disagreeing with it.
+	if (libraryTypes.some(isModuleLibraryType)) {
+		output.module = true;
+	}
+
+	// Every other library type is read out of a script, which is a statement that
+	// the output is not an ECMAScript module — so it holds the default below back.
+	const hasScriptLibrary = libraryTypes.some(
+		(type) => !isModuleLibraryType(type)
+	);
+
+	// the universal target (web + node, neither specific), deno and bun only work
+	// as ESM, unless `module: false` says the target cannot read one
+	F(output, "module", () =>
+		Boolean(
+			tp &&
+			((tp.node === null && tp.web === null && tp.module !== false) ||
+				tp.deno === true ||
+				tp.bun === true ||
+				// webpack@6 emits ESM wherever the target reads one — a browserslist
+				// query (or `esX`/`nodeX`) without ESM support keeps script output
+				(futureDefaults && tp.module !== false && !hasScriptLibrary))
+		)
+	);
 
 	const environment = /** @type {Environment} */ (output.environment);
 	/**
@@ -1747,6 +1792,12 @@ const applyOutputDefaults = (
 		"generator",
 		() => tp && optimistic(/** @type {boolean | undefined} */ (tp.generator))
 	);
+	F(
+		environment,
+		"topLevelAwait",
+		() =>
+			tp && optimistic(/** @type {boolean | undefined} */ (tp.topLevelAwait))
+	);
 	F(
 		environment,
 		"forOf",
@@ -1981,7 +2032,7 @@ const applyOutputDefaults = (
 					"For the selected environment is no default script chunk format available:\n" +
 						`${
 							tp.module
-								? "Module ('module') can be chosen when ES modules are available (please set 'experiments.outputModule' and 'output.module' to `true`)"
+								? "Module ('module') can be chosen when ES modules are available (please set 'output.module' to `true`)"
 								: ""
 						}\n` +
 						"JSONP Array push ('array-push') can be chosen when 'document' or 'importScripts' is available.\n" +
@@ -2128,16 +2179,6 @@ const applyOutputDefaults = (
 		D(trustedTypes, "onPolicyCreationFailure", "stop");
 	}
 
-	/**
-	 * Processes the provided fn.
-	 * @param {(entryDescription: EntryDescription) => void} fn iterator
-	 * @returns {void}
-	 */
-	const forEachEntry = (fn) => {
-		for (const name of Object.keys(entry)) {
-			fn(/** @type {{ [k: string]: EntryDescription }} */ (entry)[name]);
-		}
-	};
 	A(output, "enabledLibraryTypes", () => {
 		/** @type {LibraryType[]} */
 		const enabledLibraryTypes = [];
@@ -2388,6 +2429,7 @@ const applyPerformanceDefaults = (performance, { production }) => {
 	// Stands in for every check left unset, so an explicit one still wins.
 	const all = performance.all !== undefined ? performance.all : false;
 
+	D(performance, "analyzableBailouts", all);
 	D(performance, "asyncChunkWaterfalls", all);
 	D(performance, "broadContexts", all);
 	D(performance, "cacheEffectiveness", all);
@@ -2396,8 +2438,6 @@ const applyPerformanceDefaults = (performance, { production }) => {
 	D(performance, "duplicateModules", all);
 	D(performance, "duplicatePackages", all);
 	D(performance, "dynamicExports", all);
-	D(performance, "entrypointOverlap", all);
-	D(performance, "embeddedSourceMaps", all);
 	D(performance, "evalUsage", all);
 	D(performance, "hotspots", all);
 	D(performance, "legacyJavascript", all);
@@ -2410,14 +2450,13 @@ const applyPerformanceDefaults = (performance, { production }) => {
 	D(performance, "redundantDynamicImports", all);
 	D(performance, "scopeHoistingBailouts", all);
 	D(performance, "splitChunksCapped", all);
+	D(performance, "sourceMaps", all);
 	D(performance, "tinyChunks", all);
 	D(performance, "topLevelThis", all);
 	D(performance, "unsplitVendors", all);
-	D(performance, "unusedAliases", all);
-	D(performance, "unusedDefines", all);
-	D(performance, "unusedExternals", all);
-	D(performance, "unusedReexports", all);
-	D(performance, "unusedRules", all);
+	D(performance, "unusedAssets", all);
+	D(performance, "unusedConfig", all);
+	D(performance, "unusedModules", all);
 	F(performance, "hints", () => (production ? "warning" : false));
 };
 
@@ -2463,20 +2502,28 @@ const applyOptimizationDefaults = (
 	D(optimization, "mangleWasmImports", false);
 	D(optimization, "portableRecords", records);
 	D(optimization, "realContentHash", production);
-	F(optimization, "minimize", () => (production ? {} : false));
-	// A plugin can assign the `true` shorthand in `apply()`, which runs after
-	// `getNormalizedOptimizationMinimize` and so never gets normalized. The
-	// normalized type does not allow it, hence the cast.
-	if (/** @type {unknown} */ (optimization.minimize) === true) {
-		optimization.minimize = {};
+	// A plugin assigning the object shorthand in `apply()` runs after
+	// normalization: it replaces `minimizeOptions`, keeping `minimize` boolean.
+	const minimizeAssignedInApply = /** @type {unknown} */ (
+		optimization.minimize
+	);
+	if (typeof minimizeAssignedInApply === "object") {
+		optimization.minimizeOptions = /** @type {OptimizationMinimizeOptions} */ (
+			minimizeAssignedInApply
+		);
+		optimization.minimize = true;
 	}
-	const { minimize } = optimization;
-	if (minimize) {
-		// Canonicalize the object form: the JS minimizer's defaults become
-		// visible in the resolved config rather than hidden in the wiring.
-		F(minimize, "javascript", () => ({ compress: { passes: 2 } }));
-		F(minimize, "css", () => ({}));
-		F(minimize, "html", () => ({}));
+	D(optimization, "minimize", production);
+	F(optimization, "minimizeOptions", () => ({}));
+	const minimizeOptions =
+		/** @type {NonNullable<Optimization["minimizeOptions"]>} */
+		(optimization.minimizeOptions);
+	if (optimization.minimize) {
+		// Canonicalize the per-asset-type options: the JS minimizer's defaults
+		// become visible in the resolved config rather than hidden in the wiring.
+		F(minimizeOptions, "javascript", () => ({ compress: { passes: 2 } }));
+		F(minimizeOptions, "css", () => ({}));
+		F(minimizeOptions, "html", () => ({}));
 	}
 	A(optimization, "minimizer", () => [
 		{
@@ -2501,10 +2548,9 @@ const applyOptimizationDefaults = (
 					compiler
 				);
 
-				// Normalized + defaulted `optimization.minimize` is the per-asset-type
-				// object here: `false` disables a type, an object is its options.
+				// Per asset type: `false` disables that type, an object is its options.
 				const minimizeByType = /** @type {OptimizationMinimizeOptions} */ (
-					compiler.options.optimization.minimize
+					compiler.options.optimization.minimizeOptions
 				);
 				const terserOptions = minimizeByType.javascript || {
 					compress: { passes: 2 }

package/lib/config/normalization.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const util = require("util");
+const { fileUrlToPath } = require("../util/identifier");
 
 /**
  * @import {
@@ -138,6 +139,28 @@ const keyedNestedConfig = (value, fn, customKeys) => {
 	return result;
 };
 
+/**
+ * Converts a file URL to the path it names. Anything that is not a string is
+ * returned unchanged, so `false` and `undefined` pass through.
+ * @template {string | false | undefined} T
+ * @param {T} pathOrUrl an absolute path, a file URL, `false` or `undefined`
+ * @returns {T} an absolute path, `false` or `undefined`
+ */
+const optionalFileUrlToPath = (pathOrUrl) =>
+	typeof pathOrUrl === "string"
+		? /** @type {T} */ (fileUrlToPath(pathOrUrl))
+		: pathOrUrl;
+
+/**
+ * Converts every file URL of a list to the path it names.
+ * @param {(string | RegExp)[]} pathsOrUrls absolute paths, file URLs or regular expressions
+ * @returns {(string | RegExp)[]} absolute paths and regular expressions
+ */
+const fileUrlsToPaths = (pathsOrUrls) =>
+	pathsOrUrls.map((pathOrUrl) =>
+		typeof pathOrUrl === "string" ? fileUrlToPath(pathOrUrl) : pathOrUrl
+	);
+
 /**
  * Normalize `output.resourceHints` into its object form: the scalar / array /
  * function shorthand becomes `{ initial: <value> }` (with `"preload"` aliased to
@@ -162,6 +185,40 @@ const normalizeResourceHints = (resourceHints) => {
 	return { initial: alias(resourceHints) };
 };
 
+/**
+ * @typedef {object} NormalizedBuildDependencyItem
+ * @property {string} dependency request to resolve
+ * @property {boolean} optional when true the dependency may be missing
+ */
+
+/**
+ * @param {import("../../declarations/WebpackOptions").BuildDependencyItem} item build dependency
+ * @returns {NormalizedBuildDependencyItem} normalized build dependency
+ */
+const normalizeBuildDependencyItem = (item) => {
+	if (typeof item === "string") {
+		return { dependency: item, optional: false };
+	}
+	return {
+		dependency: item.dependency,
+		optional: item.optional === true
+	};
+};
+
+/**
+ * @param {import("../../declarations/WebpackOptions").FileCacheOptions["buildDependencies"]=} buildDependencies build dependencies
+ * @returns {Record<string, NormalizedBuildDependencyItem[]>} normalized build dependencies
+ */
+const normalizeBuildDependencies = (buildDependencies) => {
+	/** @type {Record<string, NormalizedBuildDependencyItem[]>} */
+	const result = Object.create(null);
+	if (buildDependencies === undefined) return result;
+	for (const key of Object.keys(buildDependencies)) {
+		result[key] = buildDependencies[key].map(normalizeBuildDependencyItem);
+	}
+	return result;
+};
+
 /**
  * Gets normalized webpack options.
  * @param {WebpackOptions} config input config
@@ -189,9 +246,11 @@ const getNormalizedWebpackOptions = (config) => ({
 							maxMemoryGenerations: cache.maxMemoryGenerations,
 							maxAge: cache.maxAge,
 							profile: cache.profile,
-							buildDependencies: cloneObject(cache.buildDependencies),
-							cacheDirectory: cache.cacheDirectory,
-							cacheLocation: cache.cacheLocation,
+							buildDependencies: normalizeBuildDependencies(
+								cache.buildDependencies
+							),
+							cacheDirectory: optionalFileUrlToPath(cache.cacheDirectory),
+							cacheLocation: optionalFileUrlToPath(cache.cacheLocation),
 							hashAlgorithm: cache.hashAlgorithm,
 							compression: cache.compression,
 							idleTimeout: cache.idleTimeout,
@@ -214,7 +273,7 @@ const getNormalizedWebpackOptions = (config) => ({
 				}
 			})
 		),
-	context: config.context,
+	context: optionalFileUrlToPath(config.context),
 	dependencies: config.dependencies,
 	devServer: optionalNestedConfig(config.devServer, (devServer) => {
 		if (devServer === false) return false;
@@ -331,7 +390,14 @@ const getNormalizedWebpackOptions = (config) => ({
 					cacheGroups: cloneObject(splitChunks.cacheGroups)
 				}
 		),
-		minimize: getNormalizedOptimizationMinimize(optimization.minimize),
+		// TODO webpack 6: normalize `minimize` to the per-asset-type object and
+		// drop `minimizeOptions` — a breaking change for what plugins read back.
+		minimize:
+			typeof optimization.minimize === "object" ? true : optimization.minimize,
+		minimizeOptions: getNormalizedOptimizationMinimizeOptions(
+			optimization.minimize,
+			optimization.minimizeOptions
+		),
 		minimizer:
 			optimization.minimizer !== undefined
 				? /** @type {OptimizationNormalized["minimizer"]} */ (
@@ -374,6 +440,9 @@ const getNormalizedWebpackOptions = (config) => ({
 			cssChunkFilename: output.cssChunkFilename,
 			clean: output.clean,
 			compareBeforeEmit: output.compareBeforeEmit,
+			copy: optionalNestedConfig(output.copy, (copy) => ({
+				patterns: typeof copy === "string" ? [copy] : [...copy]
+			})),
 			crossOriginLoading: output.crossOriginLoading,
 			devtoolFallbackModuleFilenameTemplate:
 				output.devtoolFallbackModuleFilenameTemplate,
@@ -432,7 +501,7 @@ const getNormalizedWebpackOptions = (config) => ({
 						: libraryBase.umdNamedDefine
 			},
 			module: output.module,
-			path: output.path,
+			path: optionalFileUrlToPath(output.path),
 			pathinfo: output.pathinfo,
 			publicPath: output.publicPath,
 			resourceHints: normalizeResourceHints(output.resourceHints),
@@ -474,14 +543,16 @@ const getNormalizedWebpackOptions = (config) => ({
 		nestedArray(config.plugins, (p) => p.filter(Boolean))
 	),
 	profile: config.profile,
-	recordsInputPath:
+	recordsInputPath: optionalFileUrlToPath(
 		config.recordsInputPath !== undefined
 			? config.recordsInputPath
-			: config.recordsPath,
-	recordsOutputPath:
+			: config.recordsPath
+	),
+	recordsOutputPath: optionalFileUrlToPath(
 		config.recordsOutputPath !== undefined
 			? config.recordsOutputPath
-			: config.recordsPath,
+			: config.recordsPath
+	),
 	resolve: nestedConfig(config.resolve, (resolve) => ({
 		...resolve,
 		byDependency: keyedNestedConfig(resolve.byDependency, cloneObject)
@@ -517,9 +588,15 @@ const getNormalizedWebpackOptions = (config) => ({
 				hash: contextModule.hash
 			})
 		),
-		immutablePaths: optionalNestedArray(snapshot.immutablePaths, (p) => [...p]),
-		managedPaths: optionalNestedArray(snapshot.managedPaths, (p) => [...p]),
-		unmanagedPaths: optionalNestedArray(snapshot.unmanagedPaths, (p) => [...p])
+		immutablePaths: optionalNestedArray(
+			snapshot.immutablePaths,
+			fileUrlsToPaths
+		),
+		managedPaths: optionalNestedArray(snapshot.managedPaths, fileUrlsToPaths),
+		unmanagedPaths: optionalNestedArray(
+			snapshot.unmanagedPaths,
+			fileUrlsToPaths
+		)
 	})),
 	stats: nestedConfig(config.stats, (stats) => {
 		if (stats === false) {
@@ -612,15 +689,18 @@ const getNormalizedEntryStatic = (entry) => {
 };
 
 /**
- * Gets normalized optimization minimize: the `true` shorthand becomes an empty
- * per-asset-type object, so downstream only sees `false` or the object form.
+ * Gets the per-asset-type minimize options. `minimize` itself stays a boolean,
+ * and its object form is a shorthand an explicit `minimizeOptions` overrides.
  * @param {Optimization["minimize"]} minimize minimize option
- * @returns {OptimizationNormalized["minimize"]} normalized minimize option
+ * @param {Optimization["minimizeOptions"]} minimizeOptions minimizeOptions option
+ * @returns {OptimizationNormalized["minimizeOptions"]} normalized minimize options
  */
-const getNormalizedOptimizationMinimize = (minimize) => {
-	if (minimize === undefined) return;
-	if (minimize === false) return false;
-	if (minimize === true) return {};
+const getNormalizedOptimizationMinimizeOptions = (
+	minimize,
+	minimizeOptions
+) => {
+	if (minimizeOptions !== undefined) return cloneObject(minimizeOptions);
+	if (typeof minimize !== "object") return;
 	return cloneObject(minimize);
 };
 

package/lib/config/target.js

@@ -82,6 +82,7 @@ const getDefaultTarget = (context) => {
  * @property {boolean | null} templateLiteral template literal is available
  * @property {boolean | null} asyncFunction async functions and await are available
  * @property {boolean | null} generator generator functions and yield are available
+ * @property {boolean | null} topLevelAwait top-level await is available
  * @property {(boolean | null)=} deferImport deferred evaluation (`import defer`, `import.defer()`) is available (optional; absent means "assume unavailable")
  * @property {(boolean | null)=} sourceImport source phase imports (`import source`, `import.source()`) are available (optional; absent means "assume unavailable")
  */
@@ -269,6 +270,8 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
 				arrowFunction: v(6),
 				asyncFunction: v(7, 6),
 				generator: v(4),
+				// v14.8.0
+				topLevelAwait: v(14, 8),
 				forOf: v(5),
 				destructuring: v(6),
 				bigIntLiteral: v(10, 4),
@@ -329,6 +332,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
 				templateLiteral: true,
 				asyncFunction: true,
 				generator: true,
+				topLevelAwait: true,
 				// import defer - v2.8.0
 				deferImport: v(2, 8),
 				// import source - v2.6.0
@@ -380,6 +384,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
 			arrowFunction: true,
 			asyncFunction: true,
 			generator: true,
+			topLevelAwait: true,
 			forOf: true,
 			destructuring: true,
 			bigIntLiteral: true,
@@ -437,6 +442,8 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
 				arrowFunction: v(1, 1),
 				asyncFunction: v(1, 7),
 				generator: v(1, 1),
+				// 12.0.0 - Chromium 89
+				topLevelAwait: v(12),
 				forOf: v(0, 36),
 				destructuring: v(1, 1),
 				bigIntLiteral: v(4),
@@ -486,6 +493,8 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
 				arrowFunction: v(0, 15),
 				asyncFunction: v(0, 21),
 				generator: v(0, 15),
+				// 0.52.0 - Chromium 89
+				topLevelAwait: v(0, 52),
 				forOf: v(0, 13),
 				destructuring: v(0, 15),
 				bigIntLiteral: v(0, 32),
@@ -515,6 +524,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
 				destructuring: v >= 2015,
 				module: v >= 2015,
 				asyncFunction: v >= 2017,
+				topLevelAwait: v >= 2022,
 				generator: v >= 2015,
 				globalThis: v >= 2020,
 				symbol: v >= 2015,

package/lib/container/ContainerReferencePlugin.js

@@ -14,6 +14,7 @@ const FallbackModuleFactory = require("./FallbackModuleFactory");
 const RemoteModule = require("./RemoteModule");
 const RemoteRuntimeModule = require("./RemoteRuntimeModule");
 const RemoteToExternalDependency = require("./RemoteToExternalDependency");
+const { addDeclaredRemotes } = require("./declaredRemotes");
 const { parseOptions } = require("./options");
 
 /**
@@ -91,6 +92,11 @@ class ContainerReferencePlugin {
 		compiler.hooks.compilation.tap(
 			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
+				addDeclaredRemotes(
+					compilation,
+					remotes.map(([key]) => key)
+				);
+
 				compilation.dependencyFactories.set(
 					RemoteToExternalDependency,
 					normalModuleFactory

package/lib/container/RemoteRuntimeModule.js

@@ -20,6 +20,15 @@ class RemoteRuntimeModule extends RuntimeModule {
 		super("remotes loading");
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return [[RuntimeGlobals.ensureChunkHandlers, "remotes"]];
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/container/declaredRemotes.js

@@ -0,0 +1,39 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+/** @import Compilation from "../Compilation" */
+
+/** @type {WeakMap<Compilation, Set<string>>} */
+const DECLARED_REMOTES = new WeakMap();
+
+/**
+ * The remote names this build declared, in declaration order, which is the
+ * order `factorize` resolves a request against them in.
+ * @param {Compilation} compilation the compilation
+ * @returns {Set<string> | undefined} the declared names, when any were declared
+ */
+const getDeclaredRemotes = (compilation) => DECLARED_REMOTES.get(compilation);
+
+/**
+ * Records declared names, adding to any a previous application made.
+ * @param {Compilation} compilation the compilation
+ * @param {Iterable<string>} names what this application declared
+ * @returns {void}
+ */
+const addDeclaredRemotes = (compilation, names) => {
+	let declared = DECLARED_REMOTES.get(compilation);
+
+	if (declared === undefined) {
+		declared = new Set();
+		DECLARED_REMOTES.set(compilation, declared);
+	}
+
+	for (const name of names) declared.add(name);
+};
+
+module.exports.addDeclaredRemotes = addDeclaredRemotes;
+module.exports.getDeclaredRemotes = getDeclaredRemotes;

package/lib/css/CssGenerator.js

@@ -32,6 +32,7 @@ const Template = require("../Template");
 const { getPresentKinds } = require("../TemplatedPathPlugin");
 const CssImportDependency = require("../dependencies/CssImportDependency");
 const HarmonyImportSideEffectDependency = require("../dependencies/HarmonyImportSideEffectDependency");
+const LoaderImportDependency = require("../dependencies/LoaderImportDependency");
 
 const { encodeMappings } = require("../util/createMappings");
 const {
@@ -668,6 +669,13 @@ class CssGenerator extends Generator {
 				continue;
 			}
 
+			// `importModule()` executes the module as JavaScript, and its dependency
+			// carries no origin module (`connectOrigin: false` in `LoaderPlugin`).
+			if (connection.dependency instanceof LoaderImportDependency) {
+				hasJs = true;
+				continue;
+			}
+
 			if (!connection.originModule) {
 				continue;
 			}