webpack 5.102.0 → 5.103.0

package/lib/NormalModule.js

@@ -96,7 +96,6 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("../declarations/WebpackOptions").HashFunction} HashFunction */
 /** @typedef {import("./util/identifier").AssociatedObjectForCache} AssociatedObjectForCache */
-/** @typedef {import("../declarations/WebpackOptions").RuleSetRule["extractSourceMap"]} ExtractSourceMapOptions */
 /**
  * @template T
  * @typedef {import("./util/deprecation").FakeHook<T>} FakeHook
@@ -255,7 +254,7 @@ makeSerializable(
  * @property {Generator} generator the generator used
  * @property {GeneratorOptions=} generatorOptions the options of the generator used
  * @property {ResolveOptions=} resolveOptions options used for resolving requests from this module
- * @property {boolean=} extractSourceMap enable/disable extracting source map
+ * @property {boolean} extractSourceMap enable/disable extracting source map
  */
 
 /**
@@ -353,34 +352,36 @@ class NormalModule extends Module {
 		super(type, context || getContext(resource), layer);
 
 		// Info from Factory
-		/** @type {string} */
+		/** @type {NormalModuleCreateData['request']} */
 		this.request = request;
-		/** @type {string} */
+		/** @type {NormalModuleCreateData['userRequest']} */
 		this.userRequest = userRequest;
-		/** @type {string} */
+		/** @type {NormalModuleCreateData['rawRequest']} */
 		this.rawRequest = rawRequest;
 		/** @type {boolean} */
 		this.binary = /^(asset|webassembly)\b/.test(type);
-		/** @type {undefined | Parser} */
+		/** @type {NormalModuleCreateData['parser'] | undefined} */
 		this.parser = parser;
-		/** @type {undefined | ParserOptions} */
+		/** @type {NormalModuleCreateData['parserOptions']} */
 		this.parserOptions = parserOptions;
-		/** @type {undefined | Generator} */
+		/** @type {NormalModuleCreateData['generator'] | undefined} */
 		this.generator = generator;
-		/** @type {undefined | GeneratorOptions} */
+		/** @type {NormalModuleCreateData['generatorOptions']} */
 		this.generatorOptions = generatorOptions;
-		/** @type {string} */
+		/** @type {NormalModuleCreateData['resource']} */
 		this.resource = resource;
+		/** @type {NormalModuleCreateData['resourceResolveData']} */
 		this.resourceResolveData = resourceResolveData;
-		/** @type {string | undefined} */
+		/** @type {NormalModuleCreateData['matchResource']} */
 		this.matchResource = matchResource;
-		/** @type {LoaderItem[]} */
+		/** @type {NormalModuleCreateData['loaders']} */
 		this.loaders = loaders;
 		if (resolveOptions !== undefined) {
 			// already declared in super class
+			/** @type {NormalModuleCreateData['resolveOptions']} */
 			this.resolveOptions = resolveOptions;
 		}
-		/** @type {ExtractSourceMapOptions} */
+		/** @type {NormalModuleCreateData['extractSourceMap']} */
 		this.extractSourceMap = extractSourceMap;
 
 		// Info from Build
@@ -487,6 +488,7 @@ class NormalModule extends Module {
 		this.context = m.context;
 		this.matchResource = m.matchResource;
 		this.loaders = m.loaders;
+		this.extractSourceMap = m.extractSourceMap;
 	}
 
 	/**
@@ -1211,7 +1213,7 @@ class NormalModule extends Module {
 		hash.update("meta");
 		hash.update(JSON.stringify(this.buildMeta));
 		/** @type {BuildInfo} */
-		(this.buildInfo).hash = /** @type {string} */ (hash.digest("hex"));
+		(this.buildInfo).hash = hash.digest("hex");
 	}
 
 	/**
@@ -1721,7 +1723,6 @@ class NormalModule extends Module {
 		write(this._lastSuccessfulBuildMeta);
 		write(this._forceBuild);
 		write(this._codeGeneratorData);
-		write(this.extractSourceMap);
 		super.serialize(context);
 	}
 
@@ -1746,7 +1747,8 @@ class NormalModule extends Module {
 			parserOptions: /** @type {EXPECTED_ANY} */ (null),
 			generator: /** @type {EXPECTED_ANY} */ (null),
 			generatorOptions: /** @type {EXPECTED_ANY} */ (null),
-			resolveOptions: /** @type {EXPECTED_ANY} */ (null)
+			resolveOptions: /** @type {EXPECTED_ANY} */ (null),
+			extractSourceMap: /** @type {EXPECTED_ANY} */ (null)
 		});
 		obj.deserialize(context);
 		return obj;
@@ -1762,7 +1764,6 @@ class NormalModule extends Module {
 		this._lastSuccessfulBuildMeta = read();
 		this._forceBuild = read();
 		this._codeGeneratorData = read();
-		this.extractSourceMap = read();
 		super.deserialize(context);
 	}
 }

package/lib/NormalModuleFactory.js

@@ -114,6 +114,7 @@ const {
 /** @typedef {import("./ModuleTypeConstants").ASSET_MODULE_TYPE_INLINE} ASSET_MODULE_TYPE_INLINE */
 /** @typedef {import("./ModuleTypeConstants").ASSET_MODULE_TYPE_RESOURCE} ASSET_MODULE_TYPE_RESOURCE */
 /** @typedef {import("./ModuleTypeConstants").ASSET_MODULE_TYPE_SOURCE} ASSET_MODULE_TYPE_SOURCE */
+/** @typedef {import("./ModuleTypeConstants").ASSET_MODULE_TYPE_BYTES} ASSET_MODULE_TYPE_BYTES */
 /** @typedef {import("./ModuleTypeConstants").WEBASSEMBLY_MODULE_TYPE_ASYNC} WEBASSEMBLY_MODULE_TYPE_ASYNC */
 /** @typedef {import("./ModuleTypeConstants").WEBASSEMBLY_MODULE_TYPE_SYNC} WEBASSEMBLY_MODULE_TYPE_SYNC */
 /** @typedef {import("./ModuleTypeConstants").CSS_MODULE_TYPE} CSS_MODULE_TYPE */
@@ -268,6 +269,76 @@ const ruleSetCompiler = new RuleSetCompiler([
 	new UseEffectRulePlugin()
 ]);
 
+/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("./javascript/JavascriptGenerator")} JavascriptGenerator */
+/** @typedef {import("../declarations/WebpackOptions").EmptyGeneratorOptions} EmptyGeneratorOptions */
+
+/** @typedef {import("./json/JsonParser")} JsonParser */
+/** @typedef {import("../declarations/WebpackOptions").JsonParserOptions} JsonParserOptions */
+/** @typedef {import("./json/JsonGenerator")} JsonGenerator */
+/** @typedef {import("../declarations/WebpackOptions").JsonGeneratorOptions} JsonGeneratorOptions */
+
+/** @typedef {import("./asset/AssetParser")} AssetParser */
+/** @typedef {import("./asset/AssetSourceParser")} AssetSourceParser */
+/** @typedef {import("./asset/AssetBytesParser")} AssetBytesParser */
+/** @typedef {import("../declarations/WebpackOptions").AssetParserOptions} AssetParserOptions */
+/** @typedef {import("../declarations/WebpackOptions").EmptyParserOptions} EmptyParserOptions */
+/** @typedef {import("./asset/AssetGenerator")} AssetGenerator */
+/** @typedef {import("../declarations/WebpackOptions").AssetGeneratorOptions} AssetGeneratorOptions */
+/** @typedef {import("../declarations/WebpackOptions").AssetInlineGeneratorOptions} AssetInlineGeneratorOptions */
+/** @typedef {import("../declarations/WebpackOptions").AssetResourceGeneratorOptions} AssetResourceGeneratorOptions */
+/** @typedef {import("./asset/AssetSourceGenerator")} AssetSourceGenerator */
+/** @typedef {import("./asset/AssetBytesGenerator")} AssetBytesGenerator */
+
+/** @typedef {import("./wasm-async/AsyncWebAssemblyParser")} AsyncWebAssemblyParser */
+/** @typedef {import("./wasm-sync/WebAssemblyParser")} WebAssemblyParser */
+
+/** @typedef {import("./css/CssParser")} CssParser */
+/** @typedef {import("../declarations/WebpackOptions").CssParserOptions} CssParserOptions */
+/** @typedef {import("../declarations/WebpackOptions").CssAutoParserOptions} CssAutoParserOptions */
+/** @typedef {import("../declarations/WebpackOptions").CssGlobalParserOptions} CssGlobalParserOptions */
+/** @typedef {import("../declarations/WebpackOptions").CssModuleParserOptions} CssModuleParserOptions */
+/** @typedef {import("./css/CssGenerator")} CssGenerator */
+/** @typedef {import("../declarations/WebpackOptions").CssGeneratorOptions} CssGeneratorOptions */
+/** @typedef {import("../declarations/WebpackOptions").CssGlobalGeneratorOptions} CssGlobalGeneratorOptions */
+/** @typedef {import("../declarations/WebpackOptions").CssModuleGeneratorOptions} CssModuleGeneratorOptions */
+/** @typedef {import("../declarations/WebpackOptions").CssAutoGeneratorOptions} CssAutoGeneratorOptions */
+
+/**
+ * @typedef {[
+ * [JAVASCRIPT_MODULE_TYPE_AUTO, JavascriptParser, JavascriptParserOptions, JavascriptGenerator, EmptyGeneratorOptions],
+ * [JAVASCRIPT_MODULE_TYPE_DYNAMIC, JavascriptParser, JavascriptParserOptions, JavascriptGenerator, EmptyGeneratorOptions],
+ * [JAVASCRIPT_MODULE_TYPE_ESM, JavascriptParser, JavascriptParserOptions, JavascriptGenerator, EmptyGeneratorOptions],
+ * [JSON_MODULE_TYPE, JsonParser, JsonParserOptions, JsonGenerator, JsonGeneratorOptions],
+ * [ASSET_MODULE_TYPE, AssetParser, AssetParserOptions, AssetGenerator, AssetGeneratorOptions],
+ * [ASSET_MODULE_TYPE_INLINE, AssetParser, EmptyParserOptions, AssetGenerator, AssetGeneratorOptions],
+ * [ASSET_MODULE_TYPE_RESOURCE, AssetParser, EmptyParserOptions, AssetGenerator, AssetGeneratorOptions],
+ * [ASSET_MODULE_TYPE_SOURCE, AssetSourceParser, EmptyParserOptions, AssetSourceGenerator, EmptyGeneratorOptions],
+ * [ASSET_MODULE_TYPE_BYTES, AssetBytesParser, EmptyParserOptions, AssetBytesGenerator, EmptyGeneratorOptions],
+ * [WEBASSEMBLY_MODULE_TYPE_ASYNC, AsyncWebAssemblyParser, EmptyParserOptions, Generator, EmptyParserOptions],
+ * [WEBASSEMBLY_MODULE_TYPE_SYNC, WebAssemblyParser, EmptyParserOptions, Generator, EmptyParserOptions],
+ * [CSS_MODULE_TYPE, CssParser, CssParserOptions, CssGenerator, CssGeneratorOptions],
+ * [CSS_MODULE_TYPE_AUTO, CssParser, CssAutoParserOptions, CssGenerator, CssAutoGeneratorOptions],
+ * [CSS_MODULE_TYPE_MODULE, CssParser, CssModuleParserOptions, CssGenerator, CssModuleGeneratorOptions],
+ * [CSS_MODULE_TYPE_GLOBAL, CssParser, CssGlobalParserOptions, CssGenerator, CssGlobalGeneratorOptions],
+ * [string, Parser, ParserOptions, Generator, GeneratorOptions],
+ * ]} ParsersAndGeneratorsByTypes
+ */
+
+/**
+ * @template {unknown[]} T
+ * @template {number[]} I
+ * @typedef {{ [K in keyof I]: K extends keyof I ? I[K] extends keyof T ? T[I[K]] : never : never }} ExtractTupleElements
+ */
+
+/**
+ * @template {unknown[]} T
+ * @template {number[]} A
+ * @template [R=void]
+ * @typedef {T extends [infer Head extends [string, ...unknown[]], ...infer Tail extends [string, ...unknown[]][]] ? Record<Head[0], SyncBailHook<ExtractTupleElements<Head, A>, R extends number ? Head[R] : R>> & RecordFactoryFromTuple<Tail, A, R> : unknown } RecordFactoryFromTuple
+ */
+
 class NormalModuleFactory extends ModuleFactory {
 	/**
 	 * @param {object} param params
@@ -306,15 +377,15 @@ class NormalModuleFactory extends ModuleFactory {
 			createModule: new AsyncSeriesBailHook(["createData", "resolveData"]),
 			/** @type {SyncWaterfallHook<[Module, CreateData, ResolveData]>} */
 			module: new SyncWaterfallHook(["module", "createData", "resolveData"]),
-			/** @type {HookMap<SyncBailHook<[ParserOptions], Parser | void>>} */
+			/** @type {import("tapable").TypedHookMap<RecordFactoryFromTuple<ParsersAndGeneratorsByTypes, [2], 1>>} */
 			createParser: new HookMap(() => new SyncBailHook(["parserOptions"])),
-			/** @type {HookMap<SyncBailHook<[EXPECTED_ANY, ParserOptions], void>>} */
+			/** @type {import("tapable").TypedHookMap<RecordFactoryFromTuple<ParsersAndGeneratorsByTypes, [1, 2]>>} */
 			parser: new HookMap(() => new SyncHook(["parser", "parserOptions"])),
-			/** @type {HookMap<SyncBailHook<[GeneratorOptions], Generator | void>>} */
+			/** @type {import("tapable").TypedHookMap<RecordFactoryFromTuple<ParsersAndGeneratorsByTypes, [4], 3>>} */
 			createGenerator: new HookMap(
 				() => new SyncBailHook(["generatorOptions"])
 			),
-			/** @type {HookMap<SyncBailHook<[EXPECTED_ANY, GeneratorOptions], void>>} */
+			/** @type {import("tapable").TypedHookMap<RecordFactoryFromTuple<ParsersAndGeneratorsByTypes, [3, 4]>>} */
 			generator: new HookMap(
 				() => new SyncHook(["generator", "generatorOptions"])
 			),

package/lib/RuntimeGlobals.js

@@ -78,11 +78,29 @@ module.exports.createScript = "__webpack_require__.ts";
  */
 module.exports.createScriptUrl = "__webpack_require__.tu";
 
+/**
+ * merge multiple CSS stylesheets (CSSStyleSheet or string) into one CSS text string
+ * Arguments: (sheets: Array<CSSStyleSheet | string> | CSSStyleSheet | string) => string
+ */
+module.exports.cssMergeStyleSheets = "__webpack_require__.mcs";
+
 /**
  * The current scope when getting a module from a remote
  */
 module.exports.currentRemoteGetScope = "__webpack_require__.R";
 
+/**
+ * resolve async transitive dependencies for deferred module
+ */
+module.exports.deferredModuleAsyncTransitiveDependencies =
+	"__webpack_require__.zT";
+
+/**
+ * the internal symbol for getting the async transitive dependencies for deferred module
+ */
+module.exports.deferredModuleAsyncTransitiveDependenciesSymbol =
+	"__webpack_require__.zS";
+
 /**
  * the exported property define getters function
  */
@@ -258,14 +276,14 @@ module.exports.loadScript = "__webpack_require__.l";
 module.exports.makeDeferredNamespaceObject = "__webpack_require__.z";
 
 /**
- * the internal symbol that makeDeferredNamespaceObject is using.
+ * define compatibility on export
  */
-module.exports.makeDeferredNamespaceObjectSymbol = "__webpack_require__.zS";
+module.exports.makeNamespaceObject = "__webpack_require__.r";
 
 /**
- * define compatibility on export
+ * make a optimized deferred namespace object
  */
-module.exports.makeNamespaceObject = "__webpack_require__.r";
+module.exports.makeOptimizedDeferredNamespaceObject = "__webpack_require__.zO";
 
 /**
  * the internal module object

package/lib/RuntimePlugin.js

@@ -24,7 +24,10 @@ const GetTrustedTypesPolicyRuntimeModule = require("./runtime/GetTrustedTypesPol
 const GlobalRuntimeModule = require("./runtime/GlobalRuntimeModule");
 const HasOwnPropertyRuntimeModule = require("./runtime/HasOwnPropertyRuntimeModule");
 const LoadScriptRuntimeModule = require("./runtime/LoadScriptRuntimeModule");
-const MakeDeferredNamespaceObjectRuntime = require("./runtime/MakeDeferredNamespaceObjectRuntime");
+const {
+	MakeDeferredNamespaceObjectRuntimeModule,
+	MakeOptimizedDeferredNamespaceObjectRuntimeModule
+} = require("./runtime/MakeDeferredNamespaceObjectRuntime");
 const MakeNamespaceObjectRuntimeModule = require("./runtime/MakeNamespaceObjectRuntimeModule");
 const NonceRuntimeModule = require("./runtime/NonceRuntimeModule");
 const OnChunksLoadedRuntimeModule = require("./runtime/OnChunksLoadedRuntimeModule");
@@ -78,6 +81,7 @@ const GLOBALS_ON_REQUIRE = [
 	RuntimeGlobals.loadScript,
 	RuntimeGlobals.systemContext,
 	RuntimeGlobals.onChunksLoaded,
+	RuntimeGlobals.makeOptimizedDeferredNamespaceObject,
 	RuntimeGlobals.makeDeferredNamespaceObject
 ];
 
@@ -96,11 +100,11 @@ const TREE_DEPENDENCIES = {
 		RuntimeGlobals.makeNamespaceObject,
 		RuntimeGlobals.require
 	],
+	[RuntimeGlobals.makeOptimizedDeferredNamespaceObject]: [
+		RuntimeGlobals.require
+	],
 	[RuntimeGlobals.makeDeferredNamespaceObject]: [
-		RuntimeGlobals.definePropertyGetters,
-		RuntimeGlobals.makeNamespaceObject,
 		RuntimeGlobals.createFakeNamespaceObject,
-		RuntimeGlobals.hasOwnProperty,
 		RuntimeGlobals.require
 	],
 	[RuntimeGlobals.initializeSharing]: [RuntimeGlobals.shareScopeMap],
@@ -190,12 +194,23 @@ class RuntimePlugin {
 					);
 					return true;
 				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.makeOptimizedDeferredNamespaceObject)
+				.tap("RuntimePlugin", (chunk, runtimeRequirement) => {
+					compilation.addRuntimeModule(
+						chunk,
+						new MakeOptimizedDeferredNamespaceObjectRuntimeModule(
+							runtimeRequirement.has(RuntimeGlobals.asyncModule)
+						)
+					);
+					return true;
+				});
 			compilation.hooks.runtimeRequirementInTree
 				.for(RuntimeGlobals.makeDeferredNamespaceObject)
 				.tap("RuntimePlugin", (chunk, runtimeRequirement) => {
 					compilation.addRuntimeModule(
 						chunk,
-						new MakeDeferredNamespaceObjectRuntime(
+						new MakeDeferredNamespaceObjectRuntimeModule(
 							runtimeRequirement.has(RuntimeGlobals.asyncModule)
 						)
 					);
@@ -238,7 +253,13 @@ class RuntimePlugin {
 
 					if (publicPath === "auto") {
 						const module = new AutoPublicPathRuntimeModule();
-						if (scriptType !== "module") set.add(RuntimeGlobals.global);
+						if (
+							scriptType !== "module" &&
+							!outputOptions.environment.globalThis
+						) {
+							set.add(RuntimeGlobals.global);
+						}
+
 						compilation.addRuntimeModule(chunk, module);
 					} else {
 						const module = new PublicPathRuntimeModule(publicPath);

package/lib/RuntimeTemplate.js

@@ -11,15 +11,24 @@ const Template = require("./Template");
 const {
 	getOutgoingAsyncModules
 } = require("./async-modules/AsyncModuleHelpers");
+const { ImportPhaseUtils } = require("./dependencies/ImportPhase");
 const {
 	getMakeDeferredNamespaceModeFromExportsType,
 	getOptimizedDeferredModule
 } = require("./runtime/MakeDeferredNamespaceObjectRuntime");
 const { equals } = require("./util/ArrayHelpers");
 const compileBooleanMatcher = require("./util/compileBooleanMatcher");
+const memoize = require("./util/memoize");
 const propertyAccess = require("./util/propertyAccess");
 const { forEachRuntime, subtractRuntime } = require("./util/runtime");
 
+const getHarmonyImportDependency = memoize(() =>
+	require("./dependencies/HarmonyImportDependency")
+);
+const getImportDependency = memoize(() =>
+	require("./dependencies/ImportDependency")
+);
+
 /** @typedef {import("./config/defaults").OutputNormalizedWithDefaults} OutputOptions */
 /** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
 /** @typedef {import("./Chunk")} Chunk */
@@ -32,6 +41,8 @@ const { forEachRuntime, subtractRuntime } = require("./util/runtime");
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./RequestShortener")} RequestShortener */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./dependencies/ImportPhase").ImportPhaseType} ImportPhaseType */
+/** @typedef {import("./NormalModuleFactory").ModuleDependency} ModuleDependency */
 
 /**
  * @param {Module} module the module
@@ -617,6 +628,7 @@ class RuntimeTemplate {
 	 * @param {string} options.message a message for the comment
 	 * @param {boolean=} options.strict if the current module is in strict esm mode
 	 * @param {boolean=} options.weak if the dependency is weak (will create a nice error message)
+	 * @param {Dependency} options.dependency dependency
 	 * @param {RuntimeRequirements} options.runtimeRequirements if set, will be filled with runtime requirements
 	 * @returns {string} the promise expression
 	 */
@@ -628,6 +640,7 @@ class RuntimeTemplate {
 		message,
 		strict,
 		weak,
+		dependency,
 		runtimeRequirements
 	}) {
 		if (!module) {
@@ -684,42 +697,45 @@ class RuntimeTemplate {
 				type: "statements"
 			})} } `;
 		}
-		const moduleIdExpr = this.moduleId({
-			module,
-			chunkGraph,
-			request,
-			weak
-		});
 		const exportsType = module.getExportsType(chunkGraph.moduleGraph, strict);
-		let fakeType = 16;
-		switch (exportsType) {
-			case "namespace":
+
+		const isModuleDeferred =
+			(dependency instanceof getHarmonyImportDependency() ||
+				dependency instanceof getImportDependency()) &&
+			ImportPhaseUtils.isDefer(dependency.phase) &&
+			!(/** @type {BuildMeta} */ (module.buildMeta).async);
+
+		if (isModuleDeferred) {
+			runtimeRequirements.add(RuntimeGlobals.makeDeferredNamespaceObject);
+			const mode = getMakeDeferredNamespaceModeFromExportsType(exportsType);
+			const asyncDeps = Array.from(
+				getOutgoingAsyncModules(chunkGraph.moduleGraph, module),
+				(m) => chunkGraph.getModuleId(m)
+			).filter((id) => id !== null);
+			if (asyncDeps.length) {
 				if (header) {
-					const rawModule = this.moduleRaw({
-						module,
-						chunkGraph,
-						request,
-						weak,
-						runtimeRequirements
-					});
 					appending = `.then(${this.basicFunction(
 						"",
-						`${header}return ${rawModule};`
+						`${header}return ${RuntimeGlobals.deferredModuleAsyncTransitiveDependencies}(${JSON.stringify(asyncDeps)});`
 					)})`;
 				} else {
 					runtimeRequirements.add(RuntimeGlobals.require);
-					appending = `.then(${RuntimeGlobals.require}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}))`;
+					appending = `.then(${this.returningFunction(`${RuntimeGlobals.deferredModuleAsyncTransitiveDependencies}(${JSON.stringify(asyncDeps)})`)})`;
 				}
-				break;
-			case "dynamic":
-				fakeType |= 4;
-			/* fall through */
-			case "default-with-named":
-				fakeType |= 2;
-			/* fall through */
-			case "default-only":
-				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
-				if (chunkGraph.moduleGraph.isAsync(module)) {
+				appending += `.then(${RuntimeGlobals.makeDeferredNamespaceObject}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}, ${mode}))`;
+			} else if (header) {
+				appending = `.then(${this.basicFunction(
+					"",
+					`${header}return ${RuntimeGlobals.makeDeferredNamespaceObject}(${comment}${idExpr}, ${mode});`
+				)})`;
+			} else {
+				runtimeRequirements.add(RuntimeGlobals.require);
+				appending = `.then(${RuntimeGlobals.makeDeferredNamespaceObject}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}, ${mode}))`;
+			}
+		} else {
+			let fakeType = 16;
+			switch (exportsType) {
+				case "namespace":
 					if (header) {
 						const rawModule = this.moduleRaw({
 							module,
@@ -736,23 +752,56 @@ class RuntimeTemplate {
 						runtimeRequirements.add(RuntimeGlobals.require);
 						appending = `.then(${RuntimeGlobals.require}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}))`;
 					}
-					appending += `.then(${this.returningFunction(
-						`${RuntimeGlobals.createFakeNamespaceObject}(m, ${fakeType})`,
-						"m"
-					)})`;
-				} else {
-					fakeType |= 1;
-					if (header) {
-						const returnExpression = `${RuntimeGlobals.createFakeNamespaceObject}(${moduleIdExpr}, ${fakeType})`;
-						appending = `.then(${this.basicFunction(
-							"",
-							`${header}return ${returnExpression};`
+					break;
+				case "dynamic":
+					fakeType |= 4;
+				/* fall through */
+				case "default-with-named":
+					fakeType |= 2;
+				/* fall through */
+				case "default-only":
+					runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
+					if (chunkGraph.moduleGraph.isAsync(module)) {
+						if (header) {
+							const rawModule = this.moduleRaw({
+								module,
+								chunkGraph,
+								request,
+								weak,
+								runtimeRequirements
+							});
+							appending = `.then(${this.basicFunction(
+								"",
+								`${header}return ${rawModule};`
+							)})`;
+						} else {
+							runtimeRequirements.add(RuntimeGlobals.require);
+							appending = `.then(${RuntimeGlobals.require}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}))`;
+						}
+						appending += `.then(${this.returningFunction(
+							`${RuntimeGlobals.createFakeNamespaceObject}(m, ${fakeType})`,
+							"m"
 						)})`;
 					} else {
-						appending = `.then(${RuntimeGlobals.createFakeNamespaceObject}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}, ${fakeType}))`;
+						fakeType |= 1;
+						if (header) {
+							const moduleIdExpr = this.moduleId({
+								module,
+								chunkGraph,
+								request,
+								weak
+							});
+							const returnExpression = `${RuntimeGlobals.createFakeNamespaceObject}(${moduleIdExpr}, ${fakeType})`;
+							appending = `.then(${this.basicFunction(
+								"",
+								`${header}return ${returnExpression};`
+							)})`;
+						} else {
+							appending = `.then(${RuntimeGlobals.createFakeNamespaceObject}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}, ${fakeType}))`;
+						}
 					}
-				}
-				break;
+					break;
+			}
 		}
 
 		return `${promise || "Promise.resolve()"}${appending}`;
@@ -806,7 +855,7 @@ class RuntimeTemplate {
 	 * @param {Module} options.originModule module in which the statement is emitted
 	 * @param {boolean=} options.weak true, if this is a weak dependency
 	 * @param {RuntimeRequirements} options.runtimeRequirements if set, will be filled with runtime requirements
-	 * @param {boolean=} options.defer if set, the module will be deferred
+	 * @param {ModuleDependency} options.dependency module dependency
 	 * @returns {[string, string]} the import statement and the compat statement
 	 */
 	importStatement({
@@ -818,7 +867,7 @@ class RuntimeTemplate {
 		importVar,
 		originModule,
 		weak,
-		defer,
+		dependency,
 		runtimeRequirements
 	}) {
 		if (!module) {
@@ -866,15 +915,22 @@ class RuntimeTemplate {
 		);
 		runtimeRequirements.add(RuntimeGlobals.require);
 		let importContent;
-		if (defer && !(/** @type {BuildMeta} */ (module.buildMeta).async)) {
+
+		const isModuleDeferred =
+			(dependency instanceof getHarmonyImportDependency() ||
+				dependency instanceof getImportDependency()) &&
+			ImportPhaseUtils.isDefer(dependency.phase) &&
+			!(/** @type {BuildMeta} */ (module.buildMeta).async);
+
+		if (isModuleDeferred) {
 			/** @type {Set<Module>} */
 			const outgoingAsyncModules = getOutgoingAsyncModules(moduleGraph, module);
 
 			importContent = `/* deferred harmony import */ ${optDeclaration}${importVar} = ${getOptimizedDeferredModule(
-				this,
-				exportsType,
 				moduleId,
-				Array.from(outgoingAsyncModules, (mod) => chunkGraph.getModuleId(mod))
+				exportsType,
+				Array.from(outgoingAsyncModules, (mod) => chunkGraph.getModuleId(mod)),
+				runtimeRequirements
 			)};\n`;
 
 			return [importContent, ""];
@@ -908,7 +964,7 @@ class RuntimeTemplate {
 	 * @param {InitFragment<GenerateContext>[]} options.initFragments init fragments will be added here
 	 * @param {RuntimeSpec} options.runtime runtime for which this code will be generated
 	 * @param {RuntimeRequirements} options.runtimeRequirements if set, will be filled with runtime requirements
-	 * @param {boolean=} options.defer if true, the module will be deferred.
+	 * @param {ModuleDependency} options.dependency module dependency
 	 * @returns {string} expression
 	 */
 	exportFromImport({
@@ -926,7 +982,7 @@ class RuntimeTemplate {
 		initFragments,
 		runtime,
 		runtimeRequirements,
-		defer
+		dependency
 	}) {
 		if (!module) {
 			return this.missingModule({
@@ -942,14 +998,26 @@ class RuntimeTemplate {
 			(originModule.buildMeta).strictHarmonyModule
 		);
 
-		const isDeferred =
-			defer && !(/** @type {BuildMeta} */ (module.buildMeta).async);
+		const isModuleDeferred =
+			(dependency instanceof getHarmonyImportDependency() ||
+				dependency instanceof getImportDependency()) &&
+			ImportPhaseUtils.isDefer(dependency.phase) &&
+			!(/** @type {BuildMeta} */ (module.buildMeta).async);
 
 		if (defaultInterop) {
 			// when the defaultInterop is used (when a ESM imports a CJS module),
 			if (exportName.length > 0 && exportName[0] === "default") {
-				if (isDeferred && exportsType !== "namespace") {
-					const access = `${importVar}.a${propertyAccess(exportName, 1)}`;
+				if (isModuleDeferred && exportsType !== "namespace") {
+					const exportsInfo = moduleGraph.getExportsInfo(module);
+					const name = exportName.slice(1);
+					const used = exportsInfo.getUsedName(name, runtime);
+					if (!used) {
+						const comment = Template.toNormalComment(
+							`unused export ${propertyAccess(exportName)}`
+						);
+						return `${comment} undefined`;
+					}
+					const access = `${importVar}.a${propertyAccess(used)}`;
 					if (isCall || asiSafe === undefined) {
 						return access;
 					}
@@ -993,7 +1061,7 @@ class RuntimeTemplate {
 				) {
 					return "/* __esModule */true";
 				}
-			} else if (isDeferred) {
+			} else if (isModuleDeferred) {
 				// now exportName.length is 0
 				// fall through to the end of this function, create the namespace there.
 			} else if (
@@ -1036,7 +1104,7 @@ class RuntimeTemplate {
 				? ""
 				: `${Template.toNormalComment(propertyAccess(exportName))} `;
 			const access = `${importVar}${
-				isDeferred ? ".a" : ""
+				isModuleDeferred ? ".a" : ""
 			}${comment}${propertyAccess(used)}`;
 			if (isCall && callContext === false) {
 				return asiSafe
@@ -1047,7 +1115,7 @@ class RuntimeTemplate {
 			}
 			return access;
 		}
-		if (isDeferred) {
+		if (isModuleDeferred) {
 			initFragments.push(
 				new InitFragment(
 					`var ${importVar}_deferred_namespace_cache;\n`,