webpack 5.97.1 → 5.104.1

package/lib/optimize/ConcatenatedModule.js

@@ -16,19 +16,28 @@ const {
 const ConcatenationScope = require("../ConcatenationScope");
 const { UsageState } = require("../ExportsInfo");
 const Module = require("../Module");
-const { JS_TYPES } = require("../ModuleSourceTypesConstants");
+const {
+	JAVASCRIPT_TYPE,
+	JAVASCRIPT_TYPES
+} = require("../ModuleSourceTypeConstants");
 const { JAVASCRIPT_MODULE_TYPE_ESM } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
+const { DEFAULTS } = require("../config/defaults");
 const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
+const { ImportPhaseUtils } = require("../dependencies/ImportPhase");
 const JavascriptParser = require("../javascript/JavascriptParser");
+const {
+	getMakeDeferredNamespaceModeFromExportsType,
+	getOptimizedDeferredModule
+} = require("../runtime/MakeDeferredNamespaceObjectRuntime");
 const { equals } = require("../util/ArrayHelpers");
 const LazySet = require("../util/LazySet");
 const { concatComparators } = require("../util/comparators");
 const {
 	RESERVED_NAMES,
-	findNewName,
 	addScopeSymbols,
+	findNewName,
 	getAllReferences,
 	getPathInAst,
 	getUsedNamesInScopeInfo
@@ -51,41 +60,41 @@ const {
 /** @typedef {import("eslint-scope").Scope} Scope */
 /** @typedef {import("eslint-scope").Variable} Variable */
 /** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("../config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
 /** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
+/** @typedef {import("../Module").BuildCallback} BuildCallback */
 /** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../Module").FileSystemDependencies} FileSystemDependencies */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("../Module").LibIdent} LibIdent */
+/** @typedef {import("../Module").NameForCondition} NameForCondition */
 /** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
 /** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("../ModuleParseError")} ModuleParseError */
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../WebpackError")} WebpackError */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
 /** @typedef {import("../javascript/JavascriptParser").Program} Program */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {typeof import("../util/Hash")} HashConstructor */
-/** @typedef {import("../util/concatenate").UsedNames} UsedNames */
+/** @typedef {import("../util/concatenate").ScopeInfo} ScopeInfo */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("../util/identifier").AssociatedObjectForCache} AssociatedObjectForCache */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-
 /**
  * @template T
  * @typedef {import("../InitFragment")<T>} InitFragment
@@ -98,27 +107,23 @@ const {
 
 // fix eslint-scope to support class properties correctly
 // cspell:word Referencer
-const ReferencerClass = /** @type {any} */ (Referencer);
+const ReferencerClass = Referencer;
 if (!ReferencerClass.prototype.PropertyDefinition) {
 	ReferencerClass.prototype.PropertyDefinition =
 		ReferencerClass.prototype.Property;
 }
 
-/**
- * @typedef {object} ReexportInfo
- * @property {Module} module
- * @property {string[]} export
- */
-
 /** @typedef {RawBinding | SymbolBinding} Binding */
 
+/** @typedef {string[]} ExportName */
+
 /**
  * @typedef {object} RawBinding
  * @property {ModuleInfo} info
  * @property {string} rawName
  * @property {string=} comment
- * @property {string[]} ids
- * @property {string[]} exportName
+ * @property {ExportName} ids
+ * @property {ExportName} exportName
  */
 
 /**
@@ -126,12 +131,14 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
  * @property {ConcatenatedModuleInfo} info
  * @property {string} name
  * @property {string=} comment
- * @property {string[]} ids
- * @property {string[]} exportName
+ * @property {ExportName} ids
+ * @property {ExportName} exportName
  */
 
-/** @typedef {ConcatenatedModuleInfo | ExternalModuleInfo } ModuleInfo */
-/** @typedef {ConcatenatedModuleInfo | ExternalModuleInfo | ReferenceToModuleInfo } ModuleInfoOrReference */
+/** @typedef {ConcatenatedModuleInfo | ExternalModuleInfo} ModuleInfo */
+/** @typedef {ConcatenatedModuleInfo | ExternalModuleInfo | ReferenceToModuleInfo} ModuleInfoOrReference */
+
+/** @typedef {Map<string, string>} ExportMap */
 
 /**
  * @typedef {object} ConcatenatedModuleInfo
@@ -146,16 +153,17 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
  * @property {Scope | undefined} globalScope
  * @property {Scope | undefined} moduleScope
  * @property {Map<string, string>} internalNames
- * @property {Map<string, string> | undefined} exportMap
- * @property {Map<string, string> | undefined} rawExportMap
+ * @property {ExportMap | undefined} exportMap
+ * @property {ExportMap | undefined} rawExportMap
  * @property {string=} namespaceExportSymbol
  * @property {string | undefined} namespaceObjectName
- * @property {boolean} interopNamespaceObjectUsed
- * @property {string | undefined} interopNamespaceObjectName
- * @property {boolean} interopNamespaceObject2Used
- * @property {string | undefined} interopNamespaceObject2Name
- * @property {boolean} interopDefaultAccessUsed
- * @property {string | undefined} interopDefaultAccessName
+ * @property {ConcatenationScope | undefined} concatenationScope
+ * @property {boolean} interopNamespaceObjectUsed "default-with-named" namespace
+ * @property {string | undefined} interopNamespaceObjectName "default-with-named" namespace
+ * @property {boolean} interopNamespaceObject2Used "default-only" namespace
+ * @property {string | undefined} interopNamespaceObject2Name "default-only" namespace
+ * @property {boolean} interopDefaultAccessUsed runtime namespace object that detects "__esModule"
+ * @property {string | undefined} interopDefaultAccessName runtime namespace object that detects "__esModule"
  */
 
 /**
@@ -163,27 +171,33 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
  * @property {"external"} type
  * @property {Module} module
  * @property {RuntimeSpec | boolean} runtimeCondition
+ * @property {NonDeferAccess} nonDeferAccess
  * @property {number} index
- * @property {string | undefined} name
- * @property {boolean} interopNamespaceObjectUsed
- * @property {string | undefined} interopNamespaceObjectName
- * @property {boolean} interopNamespaceObject2Used
- * @property {string | undefined} interopNamespaceObject2Name
- * @property {boolean} interopDefaultAccessUsed
- * @property {string | undefined} interopDefaultAccessName
+ * @property {string | undefined} name module.exports / harmony namespace object
+ * @property {string | undefined} deferredName deferred module.exports / harmony namespace object
+ * @property {boolean} deferred the module is deferred at least once
+ * @property {boolean} deferredNamespaceObjectUsed deferred namespace object that being used in a not-analyzable way so it must be materialized
+ * @property {string | undefined} deferredNamespaceObjectName deferred namespace object that being used in a not-analyzable way so it must be materialized
+ * @property {boolean} interopNamespaceObjectUsed "default-with-named" namespace
+ * @property {string | undefined} interopNamespaceObjectName "default-with-named" namespace
+ * @property {boolean} interopNamespaceObject2Used "default-only" namespace
+ * @property {string | undefined} interopNamespaceObject2Name "default-only" namespace
+ * @property {boolean} interopDefaultAccessUsed runtime namespace object that detects "__esModule"
+ * @property {string | undefined} interopDefaultAccessName runtime namespace object that detects "__esModule"
  */
 
 /**
  * @typedef {object} ReferenceToModuleInfo
  * @property {"reference"} type
  * @property {RuntimeSpec | boolean} runtimeCondition
+ * @property {NonDeferAccess} nonDeferAccess
  * @property {ModuleInfo} target
  */
 
 /**
  * @template T
  * @param {string} property property
- * @param {function(T[keyof T], T[keyof T]): 0 | 1 | -1} comparator comparator
+ * @param {(a: T[keyof T], b: T[keyof T]) => 0 | 1 | -1} comparator comparator
  * @returns {Comparator<T>} comparator
  */
 
@@ -220,7 +234,7 @@ const byRangeStart = createComparator("rangeStart", compareNumbers);
  * @param {Iterable<string>} iterable iterable object
  * @returns {string} joined iterable object
  */
-const joinIterableWithComma = iterable => {
+const joinIterableWithComma = (iterable) => {
 	// This is more performant than Array.from().join(", ")
 	// as it doesn't create an array
 	let str = "";
@@ -236,23 +250,45 @@ const joinIterableWithComma = iterable => {
 	return str;
 };
 
+/** @typedef {boolean} NonDeferAccess */
+
+/**
+ * @param {NonDeferAccess} a a
+ * @param {NonDeferAccess} b b
+ * @returns {NonDeferAccess} merged
+ */
+const mergeNonDeferAccess = (a, b) => a || b;
+
+/**
+ * @param {NonDeferAccess} a first
+ * @param {NonDeferAccess} b second
+ * @returns {NonDeferAccess} first - second
+ */
+const subtractNonDeferAccess = (a, b) => a && !b;
+
 /**
  * @typedef {object} ConcatenationEntry
  * @property {"concatenated" | "external"} type
  * @property {Module} module
  * @property {RuntimeSpec | boolean} runtimeCondition
+ * @property {NonDeferAccess} nonDeferAccess
  */
 
+/** @typedef {Set<ConcatenatedModuleInfo>} NeededNamespaceObjects */
+
+/** @typedef {Map<Module, ModuleInfo>} ModuleToInfoMap */
+
 /**
  * @param {ModuleGraph} moduleGraph the module graph
  * @param {ModuleInfo} info module info
- * @param {string[]} exportName exportName
- * @param {Map<Module, ModuleInfo>} moduleToInfoMap moduleToInfoMap
+ * @param {ExportName} exportName exportName
+ * @param {ModuleToInfoMap} moduleToInfoMap moduleToInfoMap
  * @param {RuntimeSpec} runtime for which runtime
  * @param {RequestShortener} requestShortener the request shortener
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
- * @param {Set<ConcatenatedModuleInfo>} neededNamespaceObjects modules for which a namespace object should be generated
+ * @param {NeededNamespaceObjects} neededNamespaceObjects modules for which a namespace object should be generated
  * @param {boolean} asCall asCall
+ * @param {boolean} depDeferred the dependency is deferred
  * @param {boolean | undefined} strictHarmonyModule strictHarmonyModule
  * @param {boolean | undefined} asiSafe asiSafe
  * @param {Set<ExportInfo>} alreadyVisited alreadyVisited
@@ -268,6 +304,7 @@ const getFinalBinding = (
 	runtimeTemplate,
 	neededNamespaceObjects,
 	asCall,
+	depDeferred,
 	strictHarmonyModule,
 	asiSafe,
 	alreadyVisited = new Set()
@@ -276,21 +313,36 @@ const getFinalBinding = (
 		moduleGraph,
 		strictHarmonyModule
 	);
+	const moduleDeferred =
+		info.type === "external" &&
+		info.deferred &&
+		!(/** @type {BuildMeta} */ (info.module.buildMeta).async);
+	const deferred = depDeferred && moduleDeferred;
 	if (exportName.length === 0) {
 		switch (exportsType) {
 			case "default-only":
-				info.interopNamespaceObject2Used = true;
+				if (deferred) info.deferredNamespaceObjectUsed = true;
+				else info.interopNamespaceObject2Used = true;
 				return {
 					info,
-					rawName: /** @type {string} */ (info.interopNamespaceObject2Name),
+					rawName: /** @type {string} */ (
+						deferred
+							? info.deferredNamespaceObjectName
+							: info.interopNamespaceObject2Name
+					),
 					ids: exportName,
 					exportName
 				};
 			case "default-with-named":
-				info.interopNamespaceObjectUsed = true;
+				if (deferred) info.deferredNamespaceObjectUsed = true;
+				else info.interopNamespaceObjectUsed = true;
 				return {
 					info,
-					rawName: /** @type {string} */ (info.interopNamespaceObjectName),
+					rawName: /** @type {string} */ (
+						deferred
+							? info.deferredNamespaceObjectName
+							: info.interopNamespaceObjectName
+					),
 					ids: exportName,
 					exportName
 				};
@@ -344,6 +396,22 @@ const getFinalBinding = (
 				switch (exportName[0]) {
 					case "default": {
 						exportName = exportName.slice(1);
+						if (deferred) {
+							return {
+								info,
+								rawName: `${info.deferredName}.a`,
+								ids: exportName,
+								exportName
+							};
+						}
+						if (moduleDeferred) {
+							return {
+								info,
+								rawName: /** @type {string} */ (info.name),
+								ids: exportName,
+								exportName
+							};
+						}
 						info.interopDefaultAccessUsed = true;
 						const defaultExport = asCall
 							? `${info.interopDefaultAccessName}()`
@@ -385,6 +453,15 @@ const getFinalBinding = (
 					exportName
 				};
 			case "external":
+				if (deferred) {
+					info.deferredNamespaceObjectUsed = true;
+					return {
+						info,
+						rawName: /** @type {string} */ (info.deferredNamespaceObjectName),
+						ids: exportName,
+						exportName
+					};
+				}
 				return {
 					info,
 					rawName:
@@ -421,7 +498,7 @@ const getFinalBinding = (
 			}
 			const directExport = info.exportMap && info.exportMap.get(exportId);
 			if (directExport) {
-				const usedName = /** @type {string[]} */ (
+				const usedName = /** @type {ExportName} */ (
 					exportsInfo.getUsedName(exportName, runtime)
 				);
 				if (!usedName) {
@@ -448,7 +525,7 @@ const getFinalBinding = (
 					exportName
 				};
 			}
-			const reexport = exportInfo.findTarget(moduleGraph, module =>
+			const reexport = exportInfo.findTarget(moduleGraph, (module) =>
 				moduleToInfoMap.has(module)
 			);
 			if (reexport === false) {
@@ -476,6 +553,7 @@ const getFinalBinding = (
 					runtimeTemplate,
 					neededNamespaceObjects,
 					asCall,
+					reexport.deferred,
 					/** @type {BuildMeta} */
 					(info.module.buildMeta).strictHarmonyModule,
 					asiSafe,
@@ -483,7 +561,7 @@ const getFinalBinding = (
 				);
 			}
 			if (info.namespaceExportSymbol) {
-				const usedName = /** @type {string[]} */ (
+				const usedName = /** @type {ExportName} */ (
 					exportsInfo.getUsedName(exportName, runtime)
 				);
 				return {
@@ -501,7 +579,7 @@ const getFinalBinding = (
 		}
 
 		case "external": {
-			const used = /** @type {string[]} */ (
+			const used = /** @type {ExportName} */ (
 				exportsInfo.getUsedName(exportName, runtime)
 			);
 			if (!used) {
@@ -515,7 +593,15 @@ const getFinalBinding = (
 			const comment = equals(used, exportName)
 				? ""
 				: Template.toNormalComment(`${exportName.join(".")}`);
-			return { info, rawName: info.name + comment, ids: used, exportName };
+			return {
+				info,
+				rawName:
+					(deferred ? info.deferredName : info.name) +
+					(deferred ? ".a" : "") +
+					comment,
+				ids: used,
+				exportName
+			};
 		}
 	}
 };
@@ -523,13 +609,14 @@ const getFinalBinding = (
 /**
  * @param {ModuleGraph} moduleGraph the module graph
  * @param {ModuleInfo} info module info
- * @param {string[]} exportName exportName
- * @param {Map<Module, ModuleInfo>} moduleToInfoMap moduleToInfoMap
+ * @param {ExportName} exportName exportName
+ * @param {ModuleToInfoMap} moduleToInfoMap moduleToInfoMap
  * @param {RuntimeSpec} runtime for which runtime
  * @param {RequestShortener} requestShortener the request shortener
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
- * @param {Set<ConcatenatedModuleInfo>} neededNamespaceObjects modules for which a namespace object should be generated
+ * @param {NeededNamespaceObjects} neededNamespaceObjects modules for which a namespace object should be generated
  * @param {boolean} asCall asCall
+ * @param {boolean} depDeferred the dependency is deferred
  * @param {boolean | undefined} callContext callContext
  * @param {boolean | undefined} strictHarmonyModule strictHarmonyModule
  * @param {boolean | undefined} asiSafe asiSafe
@@ -545,6 +632,7 @@ const getFinalName = (
 	runtimeTemplate,
 	neededNamespaceObjects,
 	asCall,
+	depDeferred,
 	callContext,
 	strictHarmonyModule,
 	asiSafe
@@ -559,6 +647,7 @@ const getFinalName = (
 		runtimeTemplate,
 		neededNamespaceObjects,
 		asCall,
+		depDeferred,
 		strictHarmonyModule,
 		asiSafe
 	);
@@ -600,9 +689,12 @@ const getFinalName = (
 
 /**
  * @typedef {object} ConcatenateModuleHooks
- * @property {SyncBailHook<[Record<string, string>], boolean | void>} exportsDefinitions
+ * @property {SyncBailHook<[ConcatenatedModule, RuntimeSpec[], string, Record<string, string>], boolean>} onDemandExportsGeneration
+ * @property {SyncBailHook<[Partial<ConcatenatedModuleInfo>, ConcatenatedModuleInfo], boolean | void>} concatenatedModuleInfo
  */
 
+/** @typedef {BuildInfo["topLevelDeclarations"]} TopLevelDeclarations */
+
 /** @type {WeakMap<Compilation, ConcatenateModuleHooks>} */
 const compilationHooksMap = new WeakMap();
 
@@ -612,7 +704,7 @@ class ConcatenatedModule extends Module {
 	 * @param {Set<Module>} modules all modules in the concatenation (including the root module)
 	 * @param {RuntimeSpec} runtime the runtime
 	 * @param {Compilation} compilation the compilation
-	 * @param {object=} associatedObjectForCache object for caching
+	 * @param {AssociatedObjectForCache=} associatedObjectForCache object for caching
 	 * @param {string | HashConstructor=} hashFunction hash function to use
 	 * @returns {ConcatenatedModule} the module
 	 */
@@ -622,7 +714,7 @@ class ConcatenatedModule extends Module {
 		runtime,
 		compilation,
 		associatedObjectForCache,
-		hashFunction = "md4"
+		hashFunction = DEFAULTS.HASH_FUNCTION
 	) {
 		const identifier = ConcatenatedModule._createIdentifier(
 			rootModule,
@@ -647,7 +739,16 @@ class ConcatenatedModule extends Module {
 		let hooks = compilationHooksMap.get(compilation);
 		if (hooks === undefined) {
 			hooks = {
-				exportsDefinitions: new SyncBailHook(["definitions"])
+				onDemandExportsGeneration: new SyncBailHook([
+					"module",
+					"runtimes",
+					"exportsFinalName",
+					"exportsSource"
+				]),
+				concatenatedModuleInfo: new SyncBailHook([
+					"updatedInfo",
+					"concatenatedModuleInfo"
+				])
 			};
 			compilationHooksMap.set(compilation, hooks);
 		}
@@ -674,7 +775,7 @@ class ConcatenatedModule extends Module {
 		this._modules = modules;
 		this._runtime = runtime;
 		this.factoryMeta = rootModule && rootModule.factoryMeta;
-		/** @type {Compilation | undefined} */
+		/** @type {Compilation} */
 		this.compilation = compilation;
 	}
 
@@ -693,11 +794,11 @@ class ConcatenatedModule extends Module {
 	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
-		return JS_TYPES;
+		return JAVASCRIPT_TYPES;
 	}
 
 	get modules() {
-		return Array.from(this._modules);
+		return [...this._modules];
 	}
 
 	/**
@@ -719,14 +820,14 @@ class ConcatenatedModule extends Module {
 
 	/**
 	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
+	 * @returns {LibIdent | null} an identifier for library inclusion
 	 */
 	libIdent(options) {
 		return this.rootModule.libIdent(options);
 	}
 
 	/**
-	 * @returns {string | null} absolute path which should be used for condition matching (usually the resource path)
+	 * @returns {NameForCondition | null} absolute path which should be used for condition matching (usually the resource path)
 	 */
 	nameForCondition() {
 		return this.rootModule.nameForCondition();
@@ -745,7 +846,7 @@ class ConcatenatedModule extends Module {
 	 * @param {Compilation} compilation the compilation
 	 * @param {ResolverWithOptions} resolver the resolver
 	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
+	 * @param {BuildCallback} callback callback function
 	 * @returns {void}
 	 */
 	build(options, compilation, resolver, fs, callback) {
@@ -771,15 +872,17 @@ class ConcatenatedModule extends Module {
 		for (const m of this._modules) {
 			// populate cacheable
 			if (!(/** @type {BuildInfo} */ (m.buildInfo).cacheable)) {
-				this.buildInfo.cacheable = false;
+				/** @type {BuildInfo} */
+				(this.buildInfo).cacheable = false;
 			}
 
 			// populate dependencies
 			for (const d of m.dependencies.filter(
-				dep =>
+				(dep) =>
 					!(dep instanceof HarmonyImportDependency) ||
 					!this._modules.has(
-						/** @type {Module} */ (compilation.moduleGraph.getModule(dep))
+						/** @type {Module} */
+						(compilation.moduleGraph.getModule(dep))
 					)
 			)) {
 				this.dependencies.push(d);
@@ -805,41 +908,45 @@ class ConcatenatedModule extends Module {
 				}
 			}
 
-			const { assets, assetsInfo, topLevelDeclarations } =
+			const { assets, assetsInfo, topLevelDeclarations, needCreateRequire } =
 				/** @type {BuildInfo} */ (m.buildInfo);
 
+			const buildInfo = /** @type {BuildInfo} */ (this.buildInfo);
+
 			// populate topLevelDeclarations
 			if (topLevelDeclarations) {
-				const topLevelDeclarations = this.buildInfo.topLevelDeclarations;
+				const topLevelDeclarations = buildInfo.topLevelDeclarations;
 				if (topLevelDeclarations !== undefined) {
 					for (const decl of topLevelDeclarations) {
 						topLevelDeclarations.add(decl);
 					}
 				}
 			} else {
-				this.buildInfo.topLevelDeclarations = undefined;
+				buildInfo.topLevelDeclarations = undefined;
+			}
+
+			// populate needCreateRequire
+			if (needCreateRequire) {
+				this.buildInfo.needCreateRequire = true;
 			}
 
 			// populate assets
 			if (assets) {
-				if (this.buildInfo.assets === undefined) {
-					this.buildInfo.assets = Object.create(null);
+				if (buildInfo.assets === undefined) {
+					buildInfo.assets = Object.create(null);
 				}
 				Object.assign(
 					/** @type {NonNullable<BuildInfo["assets"]>} */
-					(
-						/** @type {BuildInfo} */
-						(this.buildInfo).assets
-					),
+					(buildInfo.assets),
 					assets
 				);
 			}
 			if (assetsInfo) {
-				if (this.buildInfo.assetsInfo === undefined) {
-					this.buildInfo.assetsInfo = new Map();
+				if (buildInfo.assetsInfo === undefined) {
+					buildInfo.assetsInfo = new Map();
 				}
 				for (const [key, value] of assetsInfo) {
-					this.buildInfo.assetsInfo.set(key, value);
+					buildInfo.assetsInfo.set(key, value);
 				}
 			}
 		}
@@ -870,28 +977,28 @@ class ConcatenatedModule extends Module {
 	_createConcatenationList(rootModule, modulesSet, runtime, moduleGraph) {
 		/** @type {ConcatenationEntry[]} */
 		const list = [];
-		/** @type {Map<Module, RuntimeSpec | true>} */
+		/** @type {Map<Module, { runtimeCondition: RuntimeSpec | true, nonDeferAccess: NonDeferAccess }>} */
 		const existingEntries = new Map();
 
 		/**
 		 * @param {Module} module a module
-		 * @returns {Iterable<{ connection: ModuleGraphConnection, runtimeCondition: RuntimeSpec | true }>} imported modules in order
+		 * @returns {Iterable<{ connection: ModuleGraphConnection, runtimeCondition: RuntimeSpec | true, nonDeferAccess: NonDeferAccess }>} imported modules in order
 		 */
-		const getConcatenatedImports = module => {
-			const connections = Array.from(
-				moduleGraph.getOutgoingConnections(module)
-			);
+		const getConcatenatedImports = (module) => {
+			const connections = [...moduleGraph.getOutgoingConnections(module)];
 			if (module === rootModule) {
-				for (const c of moduleGraph.getOutgoingConnections(this))
+				for (const c of moduleGraph.getOutgoingConnections(this)) {
 					connections.push(c);
+				}
 			}
 			/**
-			 * @type {Array<{ connection: ModuleGraphConnection, sourceOrder: number, rangeStart: number }>}
+			 * @type {{ connection: ModuleGraphConnection, sourceOrder: number, rangeStart: number | undefined, defer?: boolean }[]}
 			 */
 			const references = connections
-				.filter(connection => {
-					if (!(connection.dependency instanceof HarmonyImportDependency))
+				.filter((connection) => {
+					if (!(connection.dependency instanceof HarmonyImportDependency)) {
 						return false;
+					}
 					return (
 						connection &&
 						connection.resolvedOriginModule === module &&
@@ -899,14 +1006,15 @@ class ConcatenatedModule extends Module {
 						connection.isTargetActive(runtime)
 					);
 				})
-				.map(connection => {
-					const dep = /** @type {HarmonyImportDependency} */ (
-						connection.dependency
-					);
+				.map((connection) => {
+					const dep =
+						/** @type {HarmonyImportDependency} */
+						(connection.dependency);
 					return {
 						connection,
-						sourceOrder: dep.sourceOrder,
-						rangeStart: dep.range && dep.range[0]
+						sourceOrder: /** @type {number} */ (dep.sourceOrder),
+						rangeStart: dep.range && dep.range[0],
+						defer: ImportPhaseUtils.isDefer(dep.phase)
 					};
 				});
 			/**
@@ -926,17 +1034,22 @@ class ConcatenatedModule extends Module {
 			 * If there is side-effects-free reexport, we can get simple deterministic result with range start comparison.
 			 */
 			references.sort(concatComparators(bySourceOrder, byRangeStart));
-			/** @type {Map<Module, { connection: ModuleGraphConnection, runtimeCondition: RuntimeSpec | true }>} */
+			/** @type {Map<Module, { connection: ModuleGraphConnection, runtimeCondition: RuntimeSpec | true, nonDeferAccess: NonDeferAccess }>} */
 			const referencesMap = new Map();
-			for (const { connection } of references) {
-				const runtimeCondition = filterRuntime(runtime, r =>
+			for (const { connection, defer } of references) {
+				const runtimeCondition = filterRuntime(runtime, (r) =>
 					connection.isTargetActive(r)
 				);
 				if (runtimeCondition === false) continue;
+				const nonDeferAccess = !defer;
 				const module = connection.module;
 				const entry = referencesMap.get(module);
 				if (entry === undefined) {
-					referencesMap.set(module, { connection, runtimeCondition });
+					referencesMap.set(module, {
+						connection,
+						runtimeCondition,
+						nonDeferAccess
+					});
 					continue;
 				}
 				entry.runtimeCondition = mergeRuntimeConditionNonFalse(
@@ -944,6 +1057,10 @@ class ConcatenatedModule extends Module {
 					runtimeCondition,
 					runtime
 				);
+				entry.nonDeferAccess = mergeNonDeferAccess(
+					entry.nonDeferAccess,
+					nonDeferAccess
+				);
 			}
 			return referencesMap.values();
 		};
@@ -951,17 +1068,25 @@ class ConcatenatedModule extends Module {
 		/**
 		 * @param {ModuleGraphConnection} connection graph connection
 		 * @param {RuntimeSpec | true} runtimeCondition runtime condition
+		 * @param {NonDeferAccess} nonDeferAccess non-defer access
 		 * @returns {void}
 		 */
-		const enterModule = (connection, runtimeCondition) => {
+		const enterModule = (connection, runtimeCondition, nonDeferAccess) => {
 			const module = connection.module;
 			if (!module) return;
 			const existingEntry = existingEntries.get(module);
-			if (existingEntry === true) {
+			if (
+				existingEntry &&
+				existingEntry.runtimeCondition === true &&
+				existingEntry.nonDeferAccess === true
+			) {
 				return;
 			}
 			if (modulesSet.has(module)) {
-				existingEntries.set(module, true);
+				existingEntries.set(module, {
+					runtimeCondition: true,
+					nonDeferAccess: true
+				});
 				if (runtimeCondition !== true) {
 					throw new Error(
 						`Cannot runtime-conditional concatenate a module (${module.identifier()} in ${this.rootModule.identifier()}, ${runtimeConditionToString(
@@ -969,33 +1094,66 @@ class ConcatenatedModule extends Module {
 						)}). This should not happen.`
 					);
 				}
+				if (nonDeferAccess !== true) {
+					throw new Error(
+						`Cannot deferred concatenate a module (${module.identifier()} in ${this.rootModule.identifier()}. This should not happen.`
+					);
+				}
 				const imports = getConcatenatedImports(module);
-				for (const { connection, runtimeCondition } of imports)
-					enterModule(connection, runtimeCondition);
+				for (const {
+					connection,
+					runtimeCondition,
+					nonDeferAccess
+				} of imports) {
+					enterModule(connection, runtimeCondition, nonDeferAccess);
+				}
 				list.push({
 					type: "concatenated",
 					module: connection.module,
-					runtimeCondition
+					runtimeCondition,
+					nonDeferAccess
 				});
 			} else {
+				/** @type {RuntimeSpec | boolean} */
+				let reducedRuntimeCondition;
+				/** @type {NonDeferAccess} */
+				let reducedNonDeferAccess;
 				if (existingEntry !== undefined) {
-					const reducedRuntimeCondition = subtractRuntimeCondition(
+					reducedRuntimeCondition = subtractRuntimeCondition(
 						runtimeCondition,
-						existingEntry,
+						existingEntry.runtimeCondition,
 						runtime
 					);
-					if (reducedRuntimeCondition === false) return;
-					runtimeCondition = reducedRuntimeCondition;
-					existingEntries.set(
-						connection.module,
-						mergeRuntimeConditionNonFalse(
-							existingEntry,
-							runtimeCondition,
-							runtime
-						)
+					reducedNonDeferAccess = subtractNonDeferAccess(
+						nonDeferAccess,
+						existingEntry.nonDeferAccess
 					);
+					if (
+						reducedRuntimeCondition === false &&
+						reducedNonDeferAccess === false
+					) {
+						return;
+					}
+					if (reducedRuntimeCondition !== false) {
+						existingEntry.runtimeCondition = mergeRuntimeConditionNonFalse(
+							existingEntry.runtimeCondition,
+							reducedRuntimeCondition,
+							runtime
+						);
+					}
+					if (reducedNonDeferAccess !== false) {
+						existingEntry.nonDeferAccess = mergeNonDeferAccess(
+							existingEntry.nonDeferAccess,
+							reducedNonDeferAccess
+						);
+					}
 				} else {
-					existingEntries.set(connection.module, runtimeCondition);
+					reducedRuntimeCondition = runtimeCondition;
+					reducedNonDeferAccess = nonDeferAccess;
+					existingEntries.set(connection.module, {
+						runtimeCondition,
+						nonDeferAccess
+					});
 				}
 				if (list.length > 0) {
 					const lastItem = list[list.length - 1];
@@ -1005,9 +1163,13 @@ class ConcatenatedModule extends Module {
 					) {
 						lastItem.runtimeCondition = mergeRuntimeCondition(
 							lastItem.runtimeCondition,
-							runtimeCondition,
+							reducedRuntimeCondition,
 							runtime
 						);
+						lastItem.nonDeferAccess = mergeNonDeferAccess(
+							lastItem.nonDeferAccess,
+							reducedNonDeferAccess
+						);
 						return;
 					}
 				}
@@ -1019,19 +1181,25 @@ class ConcatenatedModule extends Module {
 						// concatenated module)
 						return connection.module;
 					},
-					runtimeCondition
+					runtimeCondition: reducedRuntimeCondition,
+					nonDeferAccess: reducedNonDeferAccess
 				});
 			}
 		};
 
-		existingEntries.set(rootModule, true);
+		existingEntries.set(rootModule, {
+			runtimeCondition: true,
+			nonDeferAccess: true
+		});
 		const imports = getConcatenatedImports(rootModule);
-		for (const { connection, runtimeCondition } of imports)
-			enterModule(connection, runtimeCondition);
+		for (const { connection, runtimeCondition, nonDeferAccess } of imports) {
+			enterModule(connection, runtimeCondition, nonDeferAccess);
+		}
 		list.push({
 			type: "concatenated",
 			module: rootModule,
-			runtimeCondition: true
+			runtimeCondition: true,
+			nonDeferAccess: true
 		});
 
 		return list;
@@ -1040,7 +1208,7 @@ class ConcatenatedModule extends Module {
 	/**
 	 * @param {Module} rootModule the root module of the concatenation
 	 * @param {Set<Module>} modules all modules in the concatenation (including the root module)
-	 * @param {object=} associatedObjectForCache object for caching
+	 * @param {AssociatedObjectForCache=} associatedObjectForCache object for caching
 	 * @param {string | HashConstructor=} hashFunction hash function to use
 	 * @returns {string} the identifier
 	 */
@@ -1048,7 +1216,7 @@ class ConcatenatedModule extends Module {
 		rootModule,
 		modules,
 		associatedObjectForCache,
-		hashFunction = "md4"
+		hashFunction = DEFAULTS.HASH_FUNCTION
 	) {
 		const cachedMakePathsRelative = makePathsRelative.bindContextCache(
 			/** @type {string} */ (rootModule.context),
@@ -1065,10 +1233,10 @@ class ConcatenatedModule extends Module {
 	}
 
 	/**
-	 * @param {LazySet<string>} fileDependencies set where file dependencies are added to
-	 * @param {LazySet<string>} contextDependencies set where context dependencies are added to
-	 * @param {LazySet<string>} missingDependencies set where missing dependencies are added to
-	 * @param {LazySet<string>} buildDependencies set where build dependencies are added to
+	 * @param {FileSystemDependencies} fileDependencies set where file dependencies are added to
+	 * @param {FileSystemDependencies} contextDependencies set where context dependencies are added to
+	 * @param {FileSystemDependencies} missingDependencies set where missing dependencies are added to
+	 * @param {FileSystemDependencies} buildDependencies set where build dependencies are added to
 	 */
 	addCacheDependencies(
 		fileDependencies,
@@ -1096,8 +1264,13 @@ class ConcatenatedModule extends Module {
 		moduleGraph,
 		chunkGraph,
 		runtime: generationRuntime,
+		runtimes,
 		codeGenerationResults
 	}) {
+		const { concatenatedModuleInfo } = ConcatenatedModule.getCompilationHooks(
+			this.compilation
+		);
+
 		/** @type {RuntimeRequirements} */
 		const runtimeRequirements = new Set();
 		const runtime = intersectRuntime(generationRuntime, this._runtime);
@@ -1110,9 +1283,12 @@ class ConcatenatedModule extends Module {
 		);
 
 		// Set with modules that need a generated namespace object
-		/** @type {Set<ConcatenatedModuleInfo>} */
+		/** @type {NeededNamespaceObjects} */
 		const neededNamespaceObjects = new Set();
 
+		// List of all used names to avoid conflicts
+		const allUsedNames = new Set(RESERVED_NAMES);
+
 		// Generate source code and analyse scopes
 		// Prepare a ReplaceSource for the final source
 		for (const info of moduleToInfoMap.values()) {
@@ -1124,24 +1300,20 @@ class ConcatenatedModule extends Module {
 				moduleGraph,
 				chunkGraph,
 				runtime,
+				runtimes,
 				/** @type {CodeGenerationResults} */
-				(codeGenerationResults)
+				(codeGenerationResults),
+				allUsedNames
 			);
 		}
 
-		// List of all used names to avoid conflicts
-		const allUsedNames = new Set(RESERVED_NAMES);
 		// Updated Top level declarations are created by renaming
+		/** @type {TopLevelDeclarations} */
 		const topLevelDeclarations = new Set();
 
 		// List of additional names in scope for module references
-		/** @type {Map<string, { usedNames: UsedNames, alreadyCheckedScopes: Set<TODO> }>} */
+		/** @type {Map<string, ScopeInfo>} */
 		const usedNamesInScopeInfo = new Map();
-		/**
-		 * @param {string} module module identifier
-		 * @param {string} id export id
-		 * @returns {{ usedNames: UsedNames, alreadyCheckedScopes: Set<TODO> }} info
-		 */
 
 		// Set of already checked scopes
 		const ignoredScopes = new Set();
@@ -1160,9 +1332,9 @@ class ConcatenatedModule extends Module {
 				const superClassCache = new WeakMap();
 				/**
 				 * @param {Scope} scope scope
-				 * @returns {TODO} result
+				 * @returns {{ range: Range, variables: Variable[] }[]} result
 				 */
-				const getSuperClassExpressions = scope => {
+				const getSuperClassExpressions = (scope) => {
 					const cacheEntry = superClassCache.get(scope);
 					if (cacheEntry !== undefined) return cacheEntry;
 					const superClassExpressions = [];
@@ -1175,7 +1347,7 @@ class ConcatenatedModule extends Module {
 							block.superClass
 						) {
 							superClassExpressions.push({
-								range: block.superClass.range,
+								range: /** @type {Range} */ (block.superClass.range),
 								variables: childScope.variables
 							});
 						}
@@ -1192,8 +1364,9 @@ class ConcatenatedModule extends Module {
 							const match = ConcatenationScope.matchModuleReference(name);
 							if (!match) continue;
 							const referencedInfo = modulesWithInfo[match.index];
-							if (referencedInfo.type === "reference")
+							if (referencedInfo.type === "reference") {
 								throw new Error("Module reference can't point to a reference");
+							}
 							const binding = getFinalBinding(
 								moduleGraph,
 								referencedInfo,
@@ -1204,6 +1377,7 @@ class ConcatenatedModule extends Module {
 								runtimeTemplate,
 								neededNamespaceObjects,
 								false,
+								match.deferredImport,
 								/** @type {BuildMeta} */
 								(info.module.buildMeta).strictHarmonyModule,
 								true
@@ -1241,6 +1415,75 @@ class ConcatenatedModule extends Module {
 			}
 		}
 
+		/**
+		 * @param {string} name the name to find a new name for
+		 * @param {ConcatenatedModuleInfo} info the info of the module
+		 * @param {Reference[]} references the references to the name
+		 * @returns {string | undefined} the new name or undefined if the name is not found
+		 */
+		const _findNewName = (name, info, references) => {
+			const { usedNames, alreadyCheckedScopes } = getUsedNamesInScopeInfo(
+				usedNamesInScopeInfo,
+				info.module.identifier(),
+				name
+			);
+			if (allUsedNames.has(name) || usedNames.has(name)) {
+				for (const ref of references) {
+					addScopeSymbols(
+						ref.from,
+						usedNames,
+						alreadyCheckedScopes,
+						ignoredScopes
+					);
+				}
+				const newName = findNewName(
+					name,
+					allUsedNames,
+					usedNames,
+					info.module.readableIdentifier(requestShortener)
+				);
+				allUsedNames.add(newName);
+				info.internalNames.set(name, newName);
+				topLevelDeclarations.add(newName);
+				return newName;
+			}
+		};
+
+		/**
+		 * @param {string} name the name to find a new name for
+		 * @param {ConcatenatedModuleInfo} info the info of the module
+		 * @param {Reference[]} references the references to the name
+		 * @returns {string | undefined} the new name or undefined if the name is not found
+		 */
+		const _findNewNameForSpecifier = (name, info, references) => {
+			const { usedNames: moduleUsedNames, alreadyCheckedScopes } =
+				getUsedNamesInScopeInfo(
+					usedNamesInScopeInfo,
+					info.module.identifier(),
+					name
+				);
+			const referencesUsedNames = new Set();
+			for (const ref of references) {
+				addScopeSymbols(
+					ref.from,
+					referencesUsedNames,
+					alreadyCheckedScopes,
+					ignoredScopes
+				);
+			}
+			if (moduleUsedNames.has(name) || referencesUsedNames.has(name)) {
+				const newName = findNewName(
+					name,
+					allUsedNames,
+					new Set([...moduleUsedNames, ...referencesUsedNames]),
+					info.module.readableIdentifier(requestShortener)
+				);
+				allUsedNames.add(newName);
+				topLevelDeclarations.add(newName);
+				return newName;
+			}
+		};
+
 		// generate names for symbols
 		for (const info of moduleToInfoMap.values()) {
 			const { usedNames: namespaceObjectUsedNames } = getUsedNamesInScopeInfo(
@@ -1253,34 +1496,14 @@ class ConcatenatedModule extends Module {
 					const variables = /** @type {Scope} */ (info.moduleScope).variables;
 					for (const variable of variables) {
 						const name = variable.name;
-						const { usedNames, alreadyCheckedScopes } = getUsedNamesInScopeInfo(
-							usedNamesInScopeInfo,
-							info.module.identifier(),
-							name
-						);
-						if (allUsedNames.has(name) || usedNames.has(name)) {
-							const references = getAllReferences(variable);
-							for (const ref of references) {
-								addScopeSymbols(
-									ref.from,
-									usedNames,
-									alreadyCheckedScopes,
-									ignoredScopes
-								);
-							}
-							const newName = findNewName(
-								name,
-								allUsedNames,
-								usedNames,
-								info.module.readableIdentifier(requestShortener)
-							);
-							allUsedNames.add(newName);
-							info.internalNames.set(name, newName);
-							topLevelDeclarations.add(newName);
+						const references = getAllReferences(variable);
+						const newName = _findNewName(name, info, references);
+						if (newName) {
 							const source = /** @type {ReplaceSource} */ (info.source);
-							const allIdentifiers = new Set(
-								references.map(r => r.identifier).concat(variable.identifiers)
-							);
+							const allIdentifiers = new Set([
+								...references.map((r) => r.identifier),
+								...variable.identifiers
+							]);
 							for (const identifier of allIdentifiers) {
 								const r = /** @type {Range} */ (identifier.range);
 								const path = getPathInAst(
@@ -1327,7 +1550,10 @@ class ConcatenatedModule extends Module {
 					info.namespaceObjectName =
 						/** @type {string} */
 						(namespaceObjectName);
-					topLevelDeclarations.add(namespaceObjectName);
+					topLevelDeclarations.add(
+						/** @type {string} */
+						(namespaceObjectName)
+					);
 					break;
 				}
 				case "external": {
@@ -1340,6 +1566,28 @@ class ConcatenatedModule extends Module {
 					allUsedNames.add(externalName);
 					info.name = externalName;
 					topLevelDeclarations.add(externalName);
+
+					if (info.deferred) {
+						const externalName = findNewName(
+							"deferred",
+							allUsedNames,
+							namespaceObjectUsedNames,
+							info.module.readableIdentifier(requestShortener)
+						);
+						allUsedNames.add(externalName);
+						info.deferredName = externalName;
+						topLevelDeclarations.add(externalName);
+
+						const externalNameInterop = findNewName(
+							"deferredNamespaceObject",
+							allUsedNames,
+							namespaceObjectUsedNames,
+							info.module.readableIdentifier(requestShortener)
+						);
+						allUsedNames.add(externalNameInterop);
+						info.deferredNamespaceObjectName = externalNameInterop;
+						topLevelDeclarations.add(externalNameInterop);
+					}
 					break;
 				}
 			}
@@ -1357,7 +1605,8 @@ class ConcatenatedModule extends Module {
 			}
 			if (
 				buildMeta.exportsType === "default" &&
-				buildMeta.defaultObject !== "redirect"
+				buildMeta.defaultObject !== "redirect" &&
+				info.interopNamespaceObject2Used
 			) {
 				const externalNameInterop = findNewName(
 					"namespaceObject2",
@@ -1386,13 +1635,48 @@ class ConcatenatedModule extends Module {
 		for (const info of moduleToInfoMap.values()) {
 			if (info.type === "concatenated") {
 				const globalScope = /** @type {Scope} */ (info.globalScope);
+				// group references by name
+				const referencesByName = new Map();
 				for (const reference of globalScope.through) {
 					const name = reference.identifier.name;
+					if (!referencesByName.has(name)) {
+						referencesByName.set(name, []);
+					}
+					referencesByName.get(name).push(reference);
+				}
+				for (const [name, references] of referencesByName) {
 					const match = ConcatenationScope.matchModuleReference(name);
 					if (match) {
 						const referencedInfo = modulesWithInfo[match.index];
-						if (referencedInfo.type === "reference")
+						if (referencedInfo.type === "reference") {
 							throw new Error("Module reference can't point to a reference");
+						}
+						const concatenationScope = /** @type {ConcatenatedModuleInfo} */ (
+							referencedInfo
+						).concatenationScope;
+						const exportId = match.ids[0];
+						const specifier =
+							concatenationScope && concatenationScope.getRawExport(exportId);
+						if (specifier) {
+							const newName = _findNewNameForSpecifier(
+								specifier,
+								info,
+								references
+							);
+							const initFragmentChanged =
+								newName &&
+								concatenatedModuleInfo.call(
+									{
+										rawExportMap: new Map([
+											[exportId, /** @type {string} */ (newName)]
+										])
+									},
+									/** @type {ConcatenatedModuleInfo} */ (referencedInfo)
+								);
+							if (initFragmentChanged) {
+								concatenationScope.setRawExportMap(exportId, newName);
+							}
+						}
 						const finalName = getFinalName(
 							moduleGraph,
 							referencedInfo,
@@ -1403,31 +1687,35 @@ class ConcatenatedModule extends Module {
 							runtimeTemplate,
 							neededNamespaceObjects,
 							match.call,
+							match.deferredImport,
 							!match.directImport,
 							/** @type {BuildMeta} */
 							(info.module.buildMeta).strictHarmonyModule,
 							match.asiSafe
 						);
-						const r = /** @type {Range} */ (reference.identifier.range);
-						const source = /** @type {ReplaceSource} */ (info.source);
-						// range is extended by 2 chars to cover the appended "._"
-						source.replace(r[0], r[1] + 1, finalName);
+
+						for (const reference of references) {
+							const r = /** @type {Range} */ (reference.identifier.range);
+							const source = /** @type {ReplaceSource} */ (info.source);
+							// range is extended by 2 chars to cover the appended "._"
+							source.replace(r[0], r[1] + 1, finalName);
+						}
 					}
 				}
 			}
 		}
 
 		// Map with all root exposed used exports
-		/** @type {Map<string, function(RequestShortener): string>} */
+		/** @type {Map<string, (requestShortener: RequestShortener) => string>} */
 		const exportsMap = new Map();
 
 		// Set with all root exposed unused exports
 		/** @type {Set<string>} */
 		const unusedExports = new Set();
 
-		const rootInfo = /** @type {ConcatenatedModuleInfo} */ (
-			moduleToInfoMap.get(this.rootModule)
-		);
+		const rootInfo =
+			/** @type {ConcatenatedModuleInfo} */
+			(moduleToInfoMap.get(this.rootModule));
 		const strictHarmonyModule =
 			/** @type {BuildMeta} */
 			(rootInfo.module.buildMeta).strictHarmonyModule;
@@ -1442,7 +1730,7 @@ class ConcatenatedModule extends Module {
 				unusedExports.add(name);
 				continue;
 			}
-			exportsMap.set(used, requestShortener => {
+			exportsMap.set(used, (requestShortener) => {
 				try {
 					const finalName = getFinalName(
 						moduleGraph,
@@ -1455,6 +1743,7 @@ class ConcatenatedModule extends Module {
 						neededNamespaceObjects,
 						false,
 						false,
+						false,
 						strictHarmonyModule,
 						true
 					);
@@ -1475,19 +1764,17 @@ class ConcatenatedModule extends Module {
 
 		// add harmony compatibility flag (must be first because of possible circular dependencies)
 		let shouldAddHarmonyFlag = false;
+		const rootExportsInfo = moduleGraph.getExportsInfo(this);
 		if (
-			moduleGraph.getExportsInfo(this).otherExportsInfo.getUsed(runtime) !==
-			UsageState.Unused
+			rootExportsInfo.otherExportsInfo.getUsed(runtime) !== UsageState.Unused ||
+			rootExportsInfo.getReadOnlyExportInfo("__esModule").getUsed(runtime) !==
+				UsageState.Unused
 		) {
 			shouldAddHarmonyFlag = true;
 		}
 
 		// define exports
 		if (exportsMap.size > 0) {
-			const { exportsDefinitions } = ConcatenatedModule.getCompilationHooks(
-				/** @type {Compilation} */ (this.compilation)
-			);
-
 			const definitions = [];
 			for (const [key, value] of exportsMap) {
 				definitions.push(
@@ -1496,32 +1783,38 @@ class ConcatenatedModule extends Module {
 					)}`
 				);
 			}
-			const shouldSkipRenderDefinitions =
-				exportsDefinitions.call(exportsFinalName);
-
-			if (!shouldSkipRenderDefinitions) {
-				runtimeRequirements.add(RuntimeGlobals.exports);
-				runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
 
-				if (shouldAddHarmonyFlag) {
-					result.add("// ESM COMPAT FLAG\n");
-					result.add(
-						runtimeTemplate.defineEsModuleFlagStatement({
-							exportsArgument: this.exportsArgument,
-							runtimeRequirements
-						})
-					);
-				}
+			runtimeRequirements.add(RuntimeGlobals.exports);
+			runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
 
-				result.add("\n// EXPORTS\n");
+			if (shouldAddHarmonyFlag) {
+				result.add("// ESM COMPAT FLAG\n");
 				result.add(
-					`${RuntimeGlobals.definePropertyGetters}(${
-						this.exportsArgument
-					}, {${definitions.join(",")}\n});\n`
+					runtimeTemplate.defineEsModuleFlagStatement({
+						exportsArgument: this.exportsArgument,
+						runtimeRequirements
+					})
 				);
-			} else {
-				/** @type {BuildMeta} */
-				(this.buildMeta).exportsFinalName = exportsFinalName;
+			}
+
+			const exportsSource =
+				"\n// EXPORTS\n" +
+				`${RuntimeGlobals.definePropertyGetters}(${this.exportsArgument}, {${definitions.join(
+					","
+				)}\n});\n`;
+
+			const { onDemandExportsGeneration } =
+				ConcatenatedModule.getCompilationHooks(this.compilation);
+
+			if (
+				!onDemandExportsGeneration.call(
+					this,
+					runtimes,
+					exportsSource,
+					exportsFinalName
+				)
+			) {
+				result.add(exportsSource);
 			}
 		}
 
@@ -1552,6 +1845,7 @@ class ConcatenatedModule extends Module {
 						runtimeTemplate,
 						neededNamespaceObjects,
 						false,
+						false,
 						undefined,
 						/** @type {BuildMeta} */
 						(info.module.buildMeta).strictHarmonyModule,
@@ -1571,8 +1865,9 @@ class ConcatenatedModule extends Module {
 							","
 						)}\n});\n`
 					: "";
-			if (nsObj.length > 0)
+			if (nsObj.length > 0) {
 				runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
+			}
 			namespaceObjectSources.set(
 				info,
 				`
@@ -1591,8 +1886,40 @@ ${defineGetters}`
 				if (!source) continue;
 				result.add(source);
 			}
+
+			if (info.type === "external" && info.deferred) {
+				const moduleId = JSON.stringify(chunkGraph.getModuleId(info.module));
+				const loader = getOptimizedDeferredModule(
+					moduleId,
+					info.module.getExportsType(
+						moduleGraph,
+						/** @type {BuildMeta} */
+						(this.rootModule.buildMeta).strictHarmonyModule
+					),
+					// an async module will opt-out of the concat module optimization.
+					[],
+					runtimeRequirements
+				);
+				runtimeRequirements.add(RuntimeGlobals.require);
+				result.add(
+					`\n// DEFERRED EXTERNAL MODULE: ${info.module.readableIdentifier(requestShortener)}\nvar ${info.deferredName} = ${loader};`
+				);
+				if (info.deferredNamespaceObjectUsed) {
+					runtimeRequirements.add(RuntimeGlobals.makeDeferredNamespaceObject);
+					result.add(
+						`\nvar ${info.deferredNamespaceObjectName} = /*#__PURE__*/${
+							RuntimeGlobals.makeDeferredNamespaceObject
+						}(${JSON.stringify(
+							chunkGraph.getModuleId(info.module)
+						)}, ${getMakeDeferredNamespaceModeFromExportsType(
+							info.module.getExportsType(moduleGraph, strictHarmonyModule)
+						)});`
+					);
+				}
+			}
 		}
 
+		/** @type {InitFragment<ChunkRenderContext>[]} */
 		const chunkInitFragments = [];
 
 		// evaluate modules in order
@@ -1618,30 +1945,44 @@ ${defineGetters}`
 					break;
 				}
 				case "external": {
-					result.add(
-						`\n// EXTERNAL MODULE: ${info.module.readableIdentifier(
-							requestShortener
-						)}\n`
-					);
-					runtimeRequirements.add(RuntimeGlobals.require);
-					const { runtimeCondition } =
-						/** @type {ExternalModuleInfo | ReferenceToModuleInfo} */ (rawInfo);
-					const condition = runtimeTemplate.runtimeConditionExpression({
-						chunkGraph,
-						runtimeCondition,
-						runtime,
-						runtimeRequirements
-					});
-					if (condition !== "true") {
-						isConditional = true;
-						result.add(`if (${condition}) {\n`);
-					}
-					result.add(
-						`var ${info.name} = ${RuntimeGlobals.require}(${JSON.stringify(
+					// deferred case is handled in the "const info of modulesWithInfo" loop above
+					if (!info.deferred) {
+						result.add(
+							`\n// EXTERNAL MODULE: ${info.module.readableIdentifier(
+								requestShortener
+							)}\n`
+						);
+						runtimeRequirements.add(RuntimeGlobals.require);
+						const { runtimeCondition } =
+							/** @type {ExternalModuleInfo | ReferenceToModuleInfo} */
+							(rawInfo);
+						const condition = runtimeTemplate.runtimeConditionExpression({
+							chunkGraph,
+							runtimeCondition,
+							runtime,
+							runtimeRequirements
+						});
+						if (condition !== "true") {
+							isConditional = true;
+							result.add(`if (${condition}) {\n`);
+						}
+						const moduleId = JSON.stringify(
 							chunkGraph.getModuleId(info.module)
-						)});`
-					);
-					name = info.name;
+						);
+						result.add(`var ${info.name} = __webpack_require__(${moduleId});`);
+						name = info.name;
+					}
+					// If a module is deferred in other places, but used as non-deferred here,
+					// the module itself will be emitted as mod_deferred (in the case "external"),
+					// we need to emit an extra import declaration to evaluate it in order.
+					const { nonDeferAccess } =
+						/** @type {ExternalModuleInfo | ReferenceToModuleInfo} */
+						(rawInfo);
+					if (info.deferred && nonDeferAccess) {
+						result.add(
+							`\n// non-deferred import to a deferred module (${info.module.readableIdentifier(requestShortener)})\nvar ${info.name} = ${info.deferredName}.a;`
+						);
+					}
 					break;
 				}
 				default:
@@ -1672,13 +2013,14 @@ ${defineGetters}`
 		}
 
 		const data = new Map();
-		if (chunkInitFragments.length > 0)
+		if (chunkInitFragments.length > 0) {
 			data.set("chunkInitFragments", chunkInitFragments);
+		}
 		data.set("topLevelDeclarations", topLevelDeclarations);
 
 		/** @type {CodeGenerationResult} */
 		const resultEntry = {
-			sources: new Map([["javascript", new CachedSource(result)]]),
+			sources: new Map([[JAVASCRIPT_TYPE, new CachedSource(result)]]),
 			data,
 			runtimeRequirements
 		};
@@ -1687,14 +2029,16 @@ ${defineGetters}`
 	}
 
 	/**
-	 * @param {Map<Module, ModuleInfo>} modulesMap modulesMap
+	 * @param {ModuleToInfoMap} modulesMap modulesMap
 	 * @param {ModuleInfo} info info
 	 * @param {DependencyTemplates} dependencyTemplates dependencyTemplates
 	 * @param {RuntimeTemplate} runtimeTemplate runtimeTemplate
 	 * @param {ModuleGraph} moduleGraph moduleGraph
 	 * @param {ChunkGraph} chunkGraph chunkGraph
 	 * @param {RuntimeSpec} runtime runtime
+	 * @param {RuntimeSpec[]} runtimes runtimes
 	 * @param {CodeGenerationResults} codeGenerationResults codeGenerationResults
+	 * @param {Set<string>} usedNames used names
 	 */
 	_analyseModule(
 		modulesMap,
@@ -1704,13 +2048,19 @@ ${defineGetters}`
 		moduleGraph,
 		chunkGraph,
 		runtime,
-		codeGenerationResults
+		runtimes,
+		codeGenerationResults,
+		usedNames
 	) {
 		if (info.type === "concatenated") {
 			const m = info.module;
 			try {
 				// Create a concatenation scope to track and capture information
-				const concatenationScope = new ConcatenationScope(modulesMap, info);
+				const concatenationScope = new ConcatenationScope(
+					modulesMap,
+					info,
+					usedNames
+				);
 
 				// TODO cache codeGeneration results
 				const codeGenResult = m.codeGeneration({
@@ -1719,23 +2069,34 @@ ${defineGetters}`
 					moduleGraph,
 					chunkGraph,
 					runtime,
+					runtimes,
 					concatenationScope,
 					codeGenerationResults,
-					sourceTypes: JS_TYPES
+					sourceTypes: JAVASCRIPT_TYPES
 				});
-				const source = /** @type {Source} */ (
-					codeGenResult.sources.get("javascript")
-				);
+				const source =
+					/** @type {Source} */
+					(codeGenResult.sources.get(JAVASCRIPT_TYPE));
 				const data = codeGenResult.data;
 				const chunkInitFragments = data && data.get("chunkInitFragments");
 				const code = source.source().toString();
+
+				/** @type {Program} */
 				let ast;
+
 				try {
-					ast = JavascriptParser._parse(code, {
-						sourceType: "module"
-					});
+					({ ast } = JavascriptParser._parse(
+						code,
+						{
+							sourceType: "module",
+							ranges: true
+						},
+						JavascriptParser._getModuleParseFunction(this.compilation, m)
+					));
 				} catch (_err) {
-					const err = /** @type {TODO} */ (_err);
+					const err =
+						/** @type {Error & { loc?: { line: number, column: number } }} */
+						(_err);
 					if (
 						err.loc &&
 						typeof err.loc === "object" &&
@@ -1768,6 +2129,7 @@ ${defineGetters}`
 				info.chunkInitFragments = chunkInitFragments;
 				info.globalScope = globalScope;
 				info.moduleScope = moduleScope;
+				info.concatenationScope = concatenationScope;
 			} catch (err) {
 				/** @type {Error} */
 				(err).message +=
@@ -1780,7 +2142,7 @@ ${defineGetters}`
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {[ModuleInfoOrReference[], Map<Module, ModuleInfo>]} module info items
+	 * @returns {[ModuleInfoOrReference[], ModuleToInfoMap]} module info items
 	 */
 	_getModulesWithInfo(moduleGraph, runtime) {
 		const orderedConcatenationList = this._createConcatenationList(
@@ -1789,7 +2151,7 @@ ${defineGetters}`
 			runtime,
 			moduleGraph
 		);
-		/** @type {Map<Module, ModuleInfo>} */
+		/** @type {ModuleToInfoMap} */
 		const map = new Map();
 		const list = orderedConcatenationList.map((info, index) => {
 			let item = map.get(info.module);
@@ -1816,7 +2178,8 @@ ${defineGetters}`
 							interopNamespaceObject2Used: false,
 							interopNamespaceObject2Name: undefined,
 							interopDefaultAccessUsed: false,
-							interopDefaultAccessName: undefined
+							interopDefaultAccessName: undefined,
+							concatenationScope: undefined
 						};
 						break;
 					case "external":
@@ -1824,14 +2187,19 @@ ${defineGetters}`
 							type: "external",
 							module: info.module,
 							runtimeCondition: info.runtimeCondition,
+							nonDeferAccess: info.nonDeferAccess,
 							index,
 							name: undefined,
+							deferredName: undefined,
 							interopNamespaceObjectUsed: false,
 							interopNamespaceObjectName: undefined,
 							interopNamespaceObject2Used: false,
 							interopNamespaceObject2Name: undefined,
 							interopDefaultAccessUsed: false,
-							interopDefaultAccessName: undefined
+							interopDefaultAccessName: undefined,
+							deferred: moduleGraph.isDeferred(info.module),
+							deferredNamespaceObjectName: undefined,
+							deferredNamespaceObjectUsed: false
 						};
 						break;
 					default:
@@ -1849,6 +2217,7 @@ ${defineGetters}`
 			const ref = {
 				type: "reference",
 				runtimeCondition: info.runtimeCondition,
+				nonDeferAccess: info.nonDeferAccess,
 				target: item
 			};
 			return ref;