webpack 5.102.1 → 5.104.0

package/lib/optimize/ConcatenatedModule.js

@@ -16,14 +16,16 @@ 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 HarmonyImportSideEffectDependency = require("../dependencies/HarmonyImportSideEffectDependency");
-const HarmonyImportSpecifierDependency = require("../dependencies/HarmonyImportSpecifierDependency");
+const { ImportPhaseUtils } = require("../dependencies/ImportPhase");
 const JavascriptParser = require("../javascript/JavascriptParser");
 const {
 	getMakeDeferredNamespaceModeFromExportsType,
@@ -133,8 +135,10 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
  * @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
@@ -149,8 +153,8 @@ 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 {ConcatenationScope | undefined} concatenationScope
@@ -167,6 +171,7 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
  * @property {"external"} type
  * @property {Module} module
  * @property {RuntimeSpec | boolean} runtimeCondition
+ * @property {NonDeferAccess} nonDeferAccess
  * @property {number} index
  * @property {string | undefined} name module.exports / harmony namespace object
  * @property {string | undefined} deferredName deferred module.exports / harmony namespace object
@@ -185,13 +190,14 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
  * @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
  */
 
@@ -223,16 +229,6 @@ const compareNumbers = (a, b) => {
 };
 const bySourceOrder = createComparator("sourceOrder", compareNumbers);
 const byRangeStart = createComparator("rangeStart", compareNumbers);
-const moveDeferToLast = (
-	/** @type {{ defer?: boolean }} */ a,
-	/** @type {{ defer?: boolean }} */ b
-) => {
-	if (a.defer === b.defer) return 0;
-	if (a.defer) return 1;
-	return -1;
-};
-
-const INITIAL_USED_NAMES = new Set(RESERVED_NAMES);
 
 /**
  * @param {Iterable<string>} iterable iterable object
@@ -254,11 +250,28 @@ 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 */
@@ -300,11 +313,11 @@ const getFinalBinding = (
 		moduleGraph,
 		strictHarmonyModule
 	);
-	const deferred =
-		depDeferred &&
+	const moduleDeferred =
 		info.type === "external" &&
 		info.deferred &&
-		!moduleGraph.isAsync(info.module);
+		!(/** @type {BuildMeta} */ (info.module.buildMeta).async);
+	const deferred = depDeferred && moduleDeferred;
 	if (exportName.length === 0) {
 		switch (exportsType) {
 			case "default-only":
@@ -391,6 +404,14 @@ const getFinalBinding = (
 								exportName
 							};
 						}
+						if (moduleDeferred) {
+							return {
+								info,
+								rawName: /** @type {string} */ (info.name),
+								ids: exportName,
+								exportName
+							};
+						}
 						info.interopDefaultAccessUsed = true;
 						const defaultExport = asCall
 							? `${info.interopDefaultAccessName}()`
@@ -668,7 +689,7 @@ const getFinalName = (
 
 /**
  * @typedef {object} ConcatenateModuleHooks
- * @property {SyncBailHook<[ConcatenatedModule], boolean>} onDemandExportsGeneration
+ * @property {SyncBailHook<[ConcatenatedModule, RuntimeSpec[], string, Record<string, string>], boolean>} onDemandExportsGeneration
  * @property {SyncBailHook<[Partial<ConcatenatedModuleInfo>, ConcatenatedModuleInfo], boolean | void>} concatenatedModuleInfo
  */
 
@@ -718,7 +739,12 @@ class ConcatenatedModule extends Module {
 		let hooks = compilationHooksMap.get(compilation);
 		if (hooks === undefined) {
 			hooks = {
-				onDemandExportsGeneration: new SyncBailHook(["module"]),
+				onDemandExportsGeneration: new SyncBailHook([
+					"module",
+					"runtimes",
+					"exportsFinalName",
+					"exportsSource"
+				]),
 				concatenatedModuleInfo: new SyncBailHook([
 					"updatedInfo",
 					"concatenatedModuleInfo"
@@ -768,7 +794,7 @@ class ConcatenatedModule extends Module {
 	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
-		return JS_TYPES;
+		return JAVASCRIPT_TYPES;
 	}
 
 	get modules() {
@@ -951,13 +977,12 @@ 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();
-		const deferEnabled = this.compilation.options.experiments.deferImport;
 
 		/**
 		 * @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 = [...moduleGraph.getOutgoingConnections(module)];
@@ -987,9 +1012,9 @@ class ConcatenatedModule extends Module {
 						(connection.dependency);
 					return {
 						connection,
-						sourceOrder: dep.sourceOrder,
+						sourceOrder: /** @type {number} */ (dep.sourceOrder),
 						rangeStart: dep.range && dep.range[0],
-						defer: dep.defer
+						defer: ImportPhaseUtils.isDefer(dep.phase)
 					};
 				});
 			/**
@@ -1004,27 +1029,27 @@ class ConcatenatedModule extends Module {
 			 * a.a(); // first range
 			 * b.b(); // second range
 			 *
-			 * If the import is deferred, we always move it to the last.
 			 * If there is no reexport, we have the same source.
 			 * If there is reexport, but module has side effects, this will lead to reexport module only.
 			 * If there is side-effects-free reexport, we can get simple deterministic result with range start comparison.
 			 */
 			references.sort(concatComparators(bySourceOrder, byRangeStart));
-			if (deferEnabled) {
-				// do not combine those two sorts. defer is not the same as source or range which has a comparable number, defer is only moving them.
-				references.sort(moveDeferToLast);
-			}
-			/** @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) {
+			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(
@@ -1032,6 +1057,10 @@ class ConcatenatedModule extends Module {
 					runtimeCondition,
 					runtime
 				);
+				entry.nonDeferAccess = mergeNonDeferAccess(
+					entry.nonDeferAccess,
+					nonDeferAccess
+				);
 			}
 			return referencesMap.values();
 		};
@@ -1039,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(
@@ -1057,34 +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];
@@ -1094,9 +1163,13 @@ class ConcatenatedModule extends Module {
 					) {
 						lastItem.runtimeCondition = mergeRuntimeCondition(
 							lastItem.runtimeCondition,
-							runtimeCondition,
+							reducedRuntimeCondition,
 							runtime
 						);
+						lastItem.nonDeferAccess = mergeNonDeferAccess(
+							lastItem.nonDeferAccess,
+							reducedNonDeferAccess
+						);
 						return;
 					}
 				}
@@ -1108,20 +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;
@@ -1186,6 +1264,7 @@ class ConcatenatedModule extends Module {
 		moduleGraph,
 		chunkGraph,
 		runtime: generationRuntime,
+		runtimes,
 		codeGenerationResults
 	}) {
 		const { concatenatedModuleInfo } = ConcatenatedModule.getCompilationHooks(
@@ -1207,18 +1286,8 @@ class ConcatenatedModule extends Module {
 		/** @type {NeededNamespaceObjects} */
 		const neededNamespaceObjects = new Set();
 
-		// Default disallowed names
-		const allUsedNames = new Set(INITIAL_USED_NAMES);
-		const chunks = chunkGraph.getModuleChunks(this);
-
-		// Add names already used in the current chunk scope
-		for (const chunk of chunks) {
-			if (ConcatenationScope.chunkUsedNames.has(chunk)) {
-				for (const name of ConcatenationScope.chunkUsedNames.get(chunk) || []) {
-					allUsedNames.add(name);
-				}
-			}
-		}
+		// 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
@@ -1231,29 +1300,13 @@ class ConcatenatedModule extends Module {
 				moduleGraph,
 				chunkGraph,
 				runtime,
+				runtimes,
 				/** @type {CodeGenerationResults} */
 				(codeGenerationResults),
 				allUsedNames
 			);
 		}
 
-		// Record the names registered by the current ConcatenatedModule into the chunk scope
-		if (INITIAL_USED_NAMES.size !== allUsedNames.size) {
-			for (const name of allUsedNames) {
-				if (INITIAL_USED_NAMES.has(name)) continue;
-
-				for (const chunk of chunks) {
-					if (!ConcatenationScope.chunkUsedNames.has(chunk)) {
-						ConcatenationScope.chunkUsedNames.set(chunk, new Set([name]));
-					} else {
-						/** @type {Set<string>} */ (
-							ConcatenationScope.chunkUsedNames.get(chunk)
-						).add(name);
-					}
-				}
-			}
-		}
-
 		// Updated Top level declarations are created by renaming
 		/** @type {TopLevelDeclarations} */
 		const topLevelDeclarations = new Set();
@@ -1366,7 +1419,7 @@ 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
+		 * @returns {string | undefined} the new name or undefined if the name is not found
 		 */
 		const _findNewName = (name, info, references) => {
 			const { usedNames, alreadyCheckedScopes } = getUsedNamesInScopeInfo(
@@ -1400,7 +1453,7 @@ 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
+		 * @returns {string | undefined} the new name or undefined if the name is not found
 		 */
 		const _findNewNameForSpecifier = (name, info, references) => {
 			const { usedNames: moduleUsedNames, alreadyCheckedScopes } =
@@ -1731,9 +1784,6 @@ class ConcatenatedModule extends Module {
 				);
 			}
 
-			const { onDemandExportsGeneration } =
-				ConcatenatedModule.getCompilationHooks(this.compilation);
-
 			runtimeRequirements.add(RuntimeGlobals.exports);
 			runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
 
@@ -1747,21 +1797,24 @@ class ConcatenatedModule extends Module {
 				);
 			}
 
-			if (onDemandExportsGeneration.call(this)) {
-				/** @type {BuildMeta} */ (this.buildMeta).factoryExportsBinding =
-					"\n// EXPORTS\n" +
-					`${RuntimeGlobals.definePropertyGetters}(${
-						this.exportsArgument
-					}, {${definitions.join(",")}\n});\n`;
-				/** @type {BuildMeta} */ (this.buildMeta).exportsFinalName =
-					exportsFinalName;
-			} else {
-				result.add("\n// EXPORTS\n");
-				result.add(
-					`${RuntimeGlobals.definePropertyGetters}(${
-						this.exportsArgument
-					}, {${definitions.join(",")}\n});\n`
-				);
+			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);
 			}
 		}
 
@@ -1837,26 +1890,37 @@ ${defineGetters}`
 			if (info.type === "external" && info.deferred) {
 				const moduleId = JSON.stringify(chunkGraph.getModuleId(info.module));
 				const loader = getOptimizedDeferredModule(
-					runtimeTemplate,
+					moduleId,
 					info.module.getExportsType(
 						moduleGraph,
 						/** @type {BuildMeta} */
 						(this.rootModule.buildMeta).strictHarmonyModule
 					),
-					moduleId,
 					// 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 = [];
-		const deferEnabled = this.compilation.options.experiments.deferImport;
 
 		// evaluate modules in order
 		for (const rawInfo of modulesWithInfo) {
@@ -1868,41 +1932,6 @@ ${defineGetters}`
 					result.add(
 						`\n;// ${info.module.readableIdentifier(requestShortener)}\n`
 					);
-					// 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.
-					if (deferEnabled) {
-						for (const dep of info.module.dependencies) {
-							if (
-								!(/** @type {HarmonyImportDependency} */ (dep).defer) &&
-								(dep instanceof HarmonyImportSideEffectDependency ||
-									dep instanceof HarmonyImportSpecifierDependency)
-							) {
-								const referredModule = moduleGraph.getModule(dep);
-								if (!referredModule) {
-									if (dep instanceof HarmonyImportSideEffectDependency) {
-										continue;
-									} else {
-										throw new Error(
-											"Deferred module used, but no module in the graph."
-										);
-									}
-								}
-								if (moduleGraph.isDeferred(referredModule)) {
-									const deferredModuleInfo = /** @type {ExternalModuleInfo} */ (
-										modulesWithInfo.find(
-											(i) =>
-												i.type === "external" && i.module === referredModule
-										)
-									);
-									if (!deferredModuleInfo) continue;
-									result.add(
-										`\n// non-deferred import to a deferred module (${referredModule.readableIdentifier(requestShortener)})\nvar ${deferredModuleInfo.name} = ${deferredModuleInfo.deferredName}.a;`
-									);
-								}
-							}
-						}
-					}
 					result.add(/** @type {ReplaceSource} */ (info.source));
 					if (info.chunkInitFragments) {
 						for (const f of info.chunkInitFragments) chunkInitFragments.push(f);
@@ -1943,24 +1972,23 @@ ${defineGetters}`
 						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:
 					// @ts-expect-error never is expected here
 					throw new Error(`Unsupported concatenation entry type ${info.type}`);
 			}
-			if (info.type === "external" && 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)
-					)});`
-				);
-			}
 			if (info.interopNamespaceObjectUsed) {
 				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
 				result.add(
@@ -1992,7 +2020,7 @@ ${defineGetters}`
 
 		/** @type {CodeGenerationResult} */
 		const resultEntry = {
-			sources: new Map([["javascript", new CachedSource(result)]]),
+			sources: new Map([[JAVASCRIPT_TYPE, new CachedSource(result)]]),
 			data,
 			runtimeRequirements
 		};
@@ -2008,6 +2036,7 @@ ${defineGetters}`
 	 * @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
 	 */
@@ -2019,6 +2048,7 @@ ${defineGetters}`
 		moduleGraph,
 		chunkGraph,
 		runtime,
+		runtimes,
 		codeGenerationResults,
 		usedNames
 	) {
@@ -2039,21 +2069,30 @@ ${defineGetters}`
 					moduleGraph,
 					chunkGraph,
 					runtime,
+					runtimes,
 					concatenationScope,
 					codeGenerationResults,
-					sourceTypes: JS_TYPES
+					sourceTypes: JAVASCRIPT_TYPES
 				});
 				const source =
 					/** @type {Source} */
-					(codeGenResult.sources.get("javascript"));
+					(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 {Error & { loc?: { line: number, column: number } }} */
@@ -2148,6 +2187,7 @@ ${defineGetters}`
 							type: "external",
 							module: info.module,
 							runtimeCondition: info.runtimeCondition,
+							nonDeferAccess: info.nonDeferAccess,
 							index,
 							name: undefined,
 							deferredName: undefined,
@@ -2177,6 +2217,7 @@ ${defineGetters}`
 			const ref = {
 				type: "reference",
 				runtimeCondition: info.runtimeCondition,
+				nonDeferAccess: info.nonDeferAccess,
 				target: item
 			};
 			return ref;