@depup/webpack 5.110.1-depup.0 → 5.111.1-depup.0

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
@@ -341,10 +345,9 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
 		"Bun in version X.Y. Output is always ECMAScript modules. Examples: bun, bun1.1.",
 		/^bun((\d+)(?:\.(\d+))?)?$/,
 		() => ({
-			// Bun is a modern, Node.js-compatible runtime; every released version
-			// supports the full modern ECMAScript feature set, so the version is
-			// accepted but does not gate any feature. Output is always ESM, so sync
-			// CommonJS `require` is never available.
+			// Every released Bun supports the full modern feature set, so a version is
+			// accepted but gates nothing. Output is always ESM, leaving no synchronous
+			// CommonJS `require`.
 			node: true,
 			bun: true,
 			web: false,
@@ -380,6 +383,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 +441,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 +492,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 +523,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/{ContextExclusionPlugin.js → context/ContextExclusionPlugin.js}

@@ -4,7 +4,7 @@
 
 "use strict";
 
-/** @import Compiler from "./Compiler" */
+/** @import Compiler from "../Compiler" */
 
 const PLUGIN_NAME = "ContextExclusionPlugin";
 

package/lib/{ContextModule.js → context/ContextModule.js}

@@ -6,49 +6,52 @@
 "use strict";
 
 const { OriginalSource, RawSource } = require("webpack-sources");
-const AsyncDependenciesBlock = require("./AsyncDependenciesBlock");
-const Module = require("./Module");
+const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
+const Module = require("../Module");
 const {
 	JAVASCRIPT_TYPE,
 	JAVASCRIPT_TYPES
-} = require("./ModuleSourceTypeConstants");
-const { JAVASCRIPT_MODULE_TYPE_DYNAMIC } = require("./ModuleTypeConstants");
-const RuntimeGlobals = require("./RuntimeGlobals");
-const Template = require("./Template");
+} = require("../ModuleSourceTypeConstants");
+const { JAVASCRIPT_MODULE_TYPE_DYNAMIC } = require("../ModuleTypeConstants");
+const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
 const {
 	getOutgoingAsyncModules
-} = require("./async-modules/AsyncModuleHelpers");
-const { ImportPhase, ImportPhaseUtils } = require("./dependencies/ImportPhase");
-const { makeWebpackError } = require("./errors/HookWebpackError");
-const WebpackError = require("./errors/WebpackError");
+} = require("../async-modules/AsyncModuleHelpers");
+const {
+	ImportPhase,
+	ImportPhaseUtils
+} = require("../dependencies/ImportPhase");
+const { makeWebpackError } = require("../errors/HookWebpackError");
+const WebpackError = require("../errors/WebpackError");
 const {
 	compareLocations,
 	compareModulesById,
 	compareSelect,
 	concatComparators,
 	keepOriginalOrder
-} = require("./util/comparators");
+} = require("../util/comparators");
 const {
 	contextify,
 	makePathsRelative,
 	parseResource
-} = require("./util/identifier");
-const makeSerializable = require("./util/makeSerializable");
-const { propertyAccess } = require("./util/property");
+} = require("../util/identifier");
+const makeSerializable = require("../util/makeSerializable");
+const { propertyAccess } = require("../util/property");
 
 /** @import { Source } from "webpack-sources" */
-/** @import { ResolveOptions } from "../declarations/WebpackOptions" */
+/** @import { ResolveOptions } from "../../declarations/WebpackOptions" */
 /**
  * @import {
  * 	WebpackOptionsNormalizedWithDefaults as WebpackOptions
- * } from "./config/defaults"
+ * } from "../config/defaults"
  */
-/** @import Chunk, { ChunkId, ChunkName } from "./Chunk" */
-/** @import ChunkGraph, { ModuleId } from "./ChunkGraph" */
-/** @import { RawChunkGroupOptions } from "./ChunkGroup" */
-/** @import Compilation, { FileSystemDependencies } from "./Compilation" */
-/** @import Dependency, { RawReferencedExports } from "./Dependency" */
-/** @import { Snapshot } from "./FileSystemInfo" */
+/** @import Chunk, { ChunkId, ChunkName } from "../Chunk" */
+/** @import ChunkGraph, { ModuleId } from "../ChunkGraph" */
+/** @import { RawChunkGroupOptions } from "../ChunkGroup" */
+/** @import Compilation, { FileSystemDependencies } from "../Compilation" */
+/** @import Dependency, { RawReferencedExports } from "../Dependency" */
+/** @import { Snapshot } from "../FileSystemInfo" */
 /**
  * @import {
  * 	BuildCallback,
@@ -63,17 +66,17 @@ const { propertyAccess } = require("./util/property");
  * 	RuntimeRequirements,
  * 	Sources,
  * 	SourceTypes
- * } from "./Module"
+ * } from "../Module"
  */
-/** @import RequestShortener from "./RequestShortener" */
-/** @import { ResolverWithOptions } from "./ResolverFactory" */
-/** @import RuntimeTemplate from "./RuntimeTemplate" */
-/** @import ContextElementDependency from "./dependencies/ContextElementDependency" */
-/** @import { ImportAttributes } from "./javascript/JavascriptParser" */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext<[string, boolean]>} ObjectDeserializerContext */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext<[string, boolean]>} ObjectSerializerContext */
-/** @import { InputFileSystem } from "./util/fs" */
-/** @import { ImportPhaseType } from "./dependencies/ImportPhase" */
+/** @import RequestShortener from "../RequestShortener" */
+/** @import { ResolverWithOptions } from "../ResolverFactory" */
+/** @import RuntimeTemplate from "../RuntimeTemplate" */
+/** @import ContextElementDependency from "../dependencies/ContextElementDependency" */
+/** @import { ImportAttributes } from "../javascript/JavascriptParser" */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[string, boolean]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[string, boolean]>} ObjectSerializerContext */
+/** @import { InputFileSystem } from "../util/fs" */
+/** @import { ImportPhaseType } from "../dependencies/ImportPhase" */
 
 /** @typedef {"sync" | "eager" | "weak" | "async-weak" | "lazy" | "lazy-once"} ContextMode Context mode */
 
@@ -213,6 +216,7 @@ class ContextModule extends Module {
 	 * @returns {void}
 	 */
 	updateCacheModule(module) {
+		super.updateCacheModule(module);
 		const m = /** @type {ContextModule} */ (module);
 		this.resolveDependencies = m.resolveDependencies;
 		this.options = m.options;
@@ -878,7 +882,9 @@ class ContextModule extends Module {
 			}
 			const type =
 				typeof fakeMap === "number" ? fakeMap : fakeMapDataExpression;
-			return `${asyncDeps} ? ${asyncDeps}.length ? ${RuntimeGlobals.deferredModuleAsyncTransitiveDependencies}(${asyncDeps}).then(${RuntimeGlobals.makeDeferredNamespaceObject}.bind(${RuntimeGlobals.require}, id, ${type} ^ 1, true)) : ${RuntimeGlobals.makeDeferredNamespaceObject}(id, ${type} ^ 1 | 16) : ${source}`;
+			// The bound third argument absorbs the promise's resolved value, which
+			// would otherwise land in the export-names parameter.
+			return `${asyncDeps} ? ${asyncDeps}.length ? ${RuntimeGlobals.deferredModuleAsyncTransitiveDependencies}(${asyncDeps}).then(${RuntimeGlobals.makeDeferredNamespaceObject}.bind(${RuntimeGlobals.require}, id, ${type} ^ 1, undefined)) : ${RuntimeGlobals.makeDeferredNamespaceObject}(id, ${type} ^ 1 | 16) : ${source}`;
 		}
 		return source;
 	}
@@ -1212,60 +1218,11 @@ module.exports = webpackAsyncContext;`;
 		}
 		const shortMode = hasNoChunk && hasNoModuleDeferred && !hasFakeMap;
 		// Sorted before anything is keyed by request, so two items sharing one leave the
-		// same last writer in the map and in the loaders beside it.
+		// same last writer in the map.
 		const sortedItems = items.sort((a, b) => {
 			if (a.userRequest === b.userRequest) return 0;
 			return a.userRequest < b.userRequest ? -1 : 1;
 		});
-		let needEnsureChunk = !hasNoChunk;
-		/** @type {Map<string, string[]> | undefined} */
-		let loaders;
-		// Only module output can name a chunk in an `import()`, so nothing else pays for
-		// building the loaders just to throw them away.
-		if (!hasNoChunk && runtimeTemplate.isModule()) {
-			/** @type {Map<string, string[]>} */
-			const perRequest = new Map();
-			let hasAnalyzable = false;
-			let hasFallback = false;
-			/**
-			 * @param {Chunk} chunk one chunk a request needs
-			 * @returns {string} a thunk loading it, by literal name where the chunk has one
-			 */
-			const loaderFor = (chunk) => {
-				// `.ei` always imports, where `.e` skips a chunk already loaded — the same
-				// filter `blockPromise` applies before reaching for it.
-				const analyzable =
-					chunk.hasRuntime() || chunk.id === null
-						? null
-						: runtimeTemplate.analyzableChunkImport(
-								chunk,
-								"",
-								runtimeRequirements,
-								this,
-								chunkGraph
-							);
-				if (analyzable !== null) {
-					hasAnalyzable = true;
-					return runtimeTemplate.returningFunction(analyzable);
-				}
-				hasFallback = true;
-				return runtimeTemplate.returningFunction(
-					`${RuntimeGlobals.ensureChunk}(${JSON.stringify(chunk.id)})`
-				);
-			};
-			for (const item of sortedItems) {
-				perRequest.set(
-					item.userRequest,
-					/** @type {Chunk[]} */ (item.chunks).map(loaderFor)
-				);
-			}
-			// Nothing gained when no chunk can be spelled out, and the plain id map is
-			// smaller, so the loaders are only written when at least one names its chunk.
-			if (hasAnalyzable) {
-				loaders = perRequest;
-				needEnsureChunk = hasFallback;
-			}
-		}
 		/** @type {Record<string, ModuleId | (ModuleId | FakeMapType | ChunkId[] | (ModuleId[] | undefined))[]>} */
 		const map = Object.create(null);
 		for (const item of sortedItems) {
@@ -1299,16 +1256,16 @@ module.exports = webpackAsyncContext;`;
 		const asyncDepsPosition = hasNoChunk ? chunksPosition : chunksPosition + 1;
 		const requestPrefix = hasNoChunk
 			? "Promise.resolve()"
-			: loaders !== undefined
-				? hasMultipleOrNoChunks
-					? `Promise.all(ids[${chunksPosition}].map(${runtimeTemplate.returningFunction("load()", "load")}))`
-					: `ids[${chunksPosition}][0]()`
-				: hasMultipleOrNoChunks
-					? `Promise.all(ids[${chunksPosition}].map(${RuntimeGlobals.ensureChunk}))`
-					: `${RuntimeGlobals.ensureChunk}(ids[${chunksPosition}][0])`;
-		// Only the id map reads it; nothing loads a chunk when there is none to load, and
-		// a map of loaders spells out every one it could reach for.
-		if (needEnsureChunk) {
+			: hasMultipleOrNoChunks
+				? // Wrapped because `map` hands its callback an index too, which the loader
+					// would otherwise read as a fetch priority.
+					`Promise.all(ids[${chunksPosition}].map(${runtimeTemplate.returningFunction(
+						`${RuntimeGlobals.ensureChunk}(id)`,
+						"id"
+					)}))`
+				: `${RuntimeGlobals.ensureChunk}(ids[${chunksPosition}][0])`;
+		// Nothing loads a chunk when there is none to load.
+		if (!hasNoChunk) {
 			runtimeRequirements.add(RuntimeGlobals.ensureChunk);
 		}
 		const returnModuleObject = this.getReturnModuleObjectSource(
@@ -1352,26 +1309,7 @@ function webpackAsyncContext(req) {
 	return ${requestPrefix}.then(${runtimeTemplate.returningFunction(returnModuleObject)});
 }`;
 
-		// A loader is source, not data, so the map holding one is written out rather than
-		// serialized — one entry per line, keeping the request next to what loads it.
-		const mapSource =
-			loaders === undefined
-				? JSON.stringify(map, null, "\t")
-				: `{\n${Object.keys(map)
-						.map((request) => {
-							const slots =
-								/** @type {(ModuleId | FakeMapType | ChunkId[] | (ModuleId[] | undefined))[]} */
-								(map[request]).map((slot, index) =>
-									index === chunksPosition
-										? `[${/** @type {string[]} */ (loaders.get(request)).join(", ")}]`
-										: // An absent `asyncDeps` slot is `null` to `JSON.stringify`.
-											slot === undefined
-											? "null"
-											: JSON.stringify(slot)
-								);
-							return `\t${JSON.stringify(request)}: [${slots.join(", ")}]`;
-						})
-						.join(",\n")}\n}`;
+		const mapSource = JSON.stringify(map, null, "\t");
 
 		return `${cst} map = ${mapSource};
 ${webpackAsyncContext}
@@ -1538,7 +1476,7 @@ module.exports = webpackEmptyAsyncContext;`;
 		const returnModuleObject = this.getReturnModuleObjectSource(fakeMap);
 		const globImportAccess = this.getImportPropertyAccess();
 		const sortedDependencies =
-			/** @type {import("./dependencies/ContextElementDependency")[]} */
+			/** @type {import("../dependencies/ContextElementDependency")[]} */
 			(dependencies).sort((a, b) =>
 				a.userRequest < b.userRequest
 					? -1
@@ -1742,6 +1680,7 @@ module.exports = webpackEmptyAsyncContext;`;
 				ImportPhaseUtils.isDefer(this.options.phase || ImportPhase.Evaluation)
 			) {
 				set.add(RuntimeGlobals.makeDeferredNamespaceObject);
+				set.add(RuntimeGlobals.hasSynthesizedDeferredNamespace);
 			}
 		}
 		return {
@@ -1788,6 +1727,6 @@ module.exports = webpackEmptyAsyncContext;`;
 	}
 }
 
-makeSerializable(ContextModule, "webpack/lib/ContextModule");
+makeSerializable(ContextModule, "webpack/lib/context/ContextModule");
 
 module.exports = ContextModule;