webpack 5.107.2 → 5.108.0

package/lib/optimize/ConcatenatedModule.js

@@ -54,6 +54,7 @@ const {
 	runtimeConditionToString,
 	subtractRuntimeCondition
 } = require("../util/runtime");
+const { InlinedUsedName } = require("./InlineExports");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
@@ -69,6 +70,7 @@ const {
 /** @typedef {import("../Module").BuildInfo} BuildInfo */
 /** @typedef {import("../Module").FileSystemDependencies} FileSystemDependencies */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../Module").ExportsType} ExportsType */
 /** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("../Module").CodeGenerationResultData} CodeGenerationResultData */
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
@@ -84,6 +86,8 @@ const {
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../javascript/JavascriptModule").JavascriptModuleBuildInfo} JavascriptModuleBuildInfo */
+/** @typedef {import("../javascript/JavascriptModule").JavascriptModuleBuildMeta} JavascriptModuleBuildMeta */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").Scope} Scope */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").Reference} Reference */
@@ -94,7 +98,7 @@ const {
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/Hash").HashFunction} HashFunction */
 /** @typedef {import("../util/concatenate").UsedNames} UsedNames */
-/** @typedef {import("../util/concatenate").ScopeInfo} ScopeInfo */
+/** @typedef {import("../util/concatenate").UsedNamesInScopeInfo} UsedNamesInScopeInfo */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("../util/identifier").AssociatedObjectForCache} AssociatedObjectForCache */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
@@ -160,6 +164,7 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
  * @property {ExportMap | undefined} rawExportMap
  * @property {string=} namespaceExportSymbol
  * @property {string | undefined} namespaceObjectName
+ * @property {string | undefined} escapeNamespaceObjectName decoupled namespace object that keeps original export names when the exports are mangled
  * @property {ConcatenationScope | undefined} concatenationScope
  * @property {boolean} interopNamespaceObjectUsed "default-with-named" namespace
  * @property {string | undefined} interopNamespaceObjectName "default-with-named" namespace
@@ -167,6 +172,8 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
  * @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"
+ * @property {ExportsType=} exportsTypeStrict memoized getExportsType(strict=true)
+ * @property {ExportsType=} exportsTypeNonStrict memoized getExportsType(strict=false)
  */
 
 /**
@@ -177,6 +184,7 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
  * @property {NonDeferAccess} nonDeferAccess
  * @property {number} index
  * @property {string | undefined} name module.exports / harmony namespace object
+ * @property {string | undefined} escapeNamespaceObjectName decoupled namespace object that keeps original export names when the exports are mangled
  * @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
@@ -187,6 +195,8 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
  * @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"
+ * @property {ExportsType=} exportsTypeStrict memoized getExportsType(strict=true)
+ * @property {ExportsType=} exportsTypeNonStrict memoized getExportsType(strict=false)
  */
 
 /**
@@ -282,6 +292,27 @@ const subtractNonDeferAccess = (a, b) => a && !b;
 
 /** @typedef {Map<Module, ModuleInfo>} ModuleToInfoMap */
 
+/**
+ * getExportsType memoized on the info, which lives for one codeGeneration.
+ * The "dynamic" case walks the module graph, and is queried once per reference.
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {ModuleInfo} info module info
+ * @param {boolean | undefined} strict strict harmony module (undefined is treated as non-strict)
+ * @returns {ExportsType} the exports type
+ */
+const getExportsType = (moduleGraph, info, strict) => {
+	if (strict) {
+		if (info.exportsTypeStrict === undefined) {
+			info.exportsTypeStrict = info.module.getExportsType(moduleGraph, true);
+		}
+		return info.exportsTypeStrict;
+	}
+	if (info.exportsTypeNonStrict === undefined) {
+		info.exportsTypeNonStrict = info.module.getExportsType(moduleGraph, false);
+	}
+	return info.exportsTypeNonStrict;
+};
+
 /**
  * @param {ModuleGraph} moduleGraph the module graph
  * @param {ModuleInfo} info module info
@@ -295,7 +326,7 @@ const subtractNonDeferAccess = (a, b) => a && !b;
  * @param {boolean} depDeferred the dependency is deferred
  * @param {boolean | undefined} strictHarmonyModule strictHarmonyModule
  * @param {boolean | undefined} asiSafe asiSafe
- * @param {Set<ExportInfo>} alreadyVisited alreadyVisited
+ * @param {Set<ExportInfo>=} alreadyVisited alreadyVisited
  * @returns {Binding} the final variable
  */
 const getFinalBinding = (
@@ -311,12 +342,9 @@ const getFinalBinding = (
 	depDeferred,
 	strictHarmonyModule,
 	asiSafe,
-	alreadyVisited = new Set()
+	alreadyVisited
 ) => {
-	const exportsType = info.module.getExportsType(
-		moduleGraph,
-		strictHarmonyModule
-	);
+	const exportsType = getExportsType(moduleGraph, info, strictHarmonyModule);
 	const moduleDeferred =
 		info.type === "external" &&
 		info.deferred &&
@@ -504,6 +532,9 @@ const getFinalBinding = (
 	}
 	const exportsInfo = moduleGraph.getExportsInfo(info.module);
 	const exportInfo = exportsInfo.getExportInfo(exportName[0]);
+	// Lazily allocate: only the reexport-following recursion below needs it,
+	// most calls return before reaching this point.
+	if (alreadyVisited === undefined) alreadyVisited = new Set();
 	if (alreadyVisited.has(exportInfo)) {
 		return {
 			info,
@@ -528,9 +559,7 @@ const getFinalBinding = (
 			}
 			const directExport = info.exportMap && info.exportMap.get(exportId);
 			if (directExport) {
-				const usedName = /** @type {ExportName} */ (
-					exportsInfo.getUsedName(exportName, runtime)
-				);
+				const usedName = exportsInfo.getUsedName(exportName, runtime);
 				if (!usedName) {
 					return {
 						info,
@@ -539,10 +568,26 @@ const getFinalBinding = (
 						exportName
 					};
 				}
+				if (usedName instanceof InlinedUsedName) {
+					return {
+						info,
+						// Render the inlined literal only (e.g. `"str"`), not its property
+						// suffix: that suffix is returned in `ids` and appended once by
+						// getFinalName. Using `usedName.render()` would emit it here too,
+						// duplicating the access (e.g. `"str".a.a`).
+						rawName: usedName.render(
+							Template.toNormalComment(
+								`inlined export ${propertyAccess(exportName)}`
+							)
+						),
+						ids: usedName.suffix,
+						exportName
+					};
+				}
 				return {
 					info,
 					name: directExport,
-					ids: usedName.slice(1),
+					ids: /** @type {ExportName} */ (usedName).slice(1),
 					exportName
 				};
 			}
@@ -559,6 +604,27 @@ const getFinalBinding = (
 				moduleToInfoMap.has(module)
 			);
 			if (reexport === false) {
+				// Source module was removed because all its exports were inlined;
+				// we render the inlined value here instead of binding to the now-absent module.
+				const target = exportInfo.getTarget(moduleGraph);
+				if (target && target.export) {
+					const usedName = moduleGraph
+						.getExportsInfo(target.module)
+						.getUsedName([...target.export, ...exportName.slice(1)], runtime);
+					if (usedName instanceof InlinedUsedName) {
+						return {
+							info,
+							// Literal only; suffix is appended once via `ids` (see directExport branch).
+							rawName: usedName.render(
+								Template.toNormalComment(
+									`inlined export ${propertyAccess(exportName)}`
+								)
+							),
+							ids: usedName.suffix,
+							exportName
+						};
+					}
+				}
 				throw new Error(
 					`Target module of reexport from '${info.module.readableIdentifier(
 						requestShortener
@@ -609,9 +675,7 @@ const getFinalBinding = (
 		}
 
 		case "external": {
-			const used = /** @type {ExportName} */ (
-				exportsInfo.getUsedName(exportName, runtime)
-			);
+			const used = exportsInfo.getUsedName(exportName, runtime);
 			if (!used) {
 				return {
 					info,
@@ -620,7 +684,21 @@ const getFinalBinding = (
 					exportName
 				};
 			}
-			const comment = equals(used, exportName)
+			if (used instanceof InlinedUsedName) {
+				return {
+					info,
+					// Literal only; suffix is appended once via `ids` (see directExport branch).
+					rawName: used.render(
+						Template.toNormalComment(
+							`inlined export ${propertyAccess(exportName)}`
+						)
+					),
+					ids: used.suffix,
+					exportName
+				};
+			}
+			const usedName = /** @type {ExportName} */ (used);
+			const comment = equals(usedName, exportName)
 				? ""
 				: Template.toNormalComment(`${exportName.join(".")}`);
 			return {
@@ -629,7 +707,7 @@ const getFinalBinding = (
 					(deferred ? info.deferredName : info.name) +
 					(deferred ? ".a" : "") +
 					comment,
-				ids: used,
+				ids: usedName,
 				exportName
 			};
 		}
@@ -727,6 +805,18 @@ const getFinalName = (
 
 /** @typedef {BuildInfo["topLevelDeclarations"]} TopLevelDeclarations */
 
+/**
+ * Defines the build info properties specific to concatenated modules.
+ * @typedef {object} KnownConcatenatedModuleBuildInfo
+ * @property {FileSystemDependencies=} fileDependencies
+ * @property {FileSystemDependencies=} contextDependencies
+ * @property {FileSystemDependencies=} missingDependencies
+ * @property {boolean=} needCreateRequire collected from the inner modules
+ * @property {boolean=} inlineExports taken over from the root module
+ */
+
+/** @typedef {BuildInfo & KnownConcatenatedModuleBuildInfo} ConcatenatedModuleBuildInfo */
+
 /** @type {WeakMap<Compilation, ConcatenateModuleHooks>} */
 const compilationHooksMap = new WeakMap();
 
@@ -798,6 +888,12 @@ class ConcatenatedModule extends Module {
 	constructor({ identifier, rootModule, modules, runtime, compilation }) {
 		super(JAVASCRIPT_MODULE_TYPE_ESM, null, rootModule && rootModule.layer);
 
+		// Redeclared with the concatenated module specific shape
+		/** @type {ConcatenatedModuleBuildInfo | undefined} */
+		this.buildInfo = undefined;
+		/** @type {JavascriptModuleBuildMeta | undefined} */
+		this.buildMeta = undefined;
+
 		// Info from Factory
 		/** @type {string} */
 		this._identifier = identifier;
@@ -805,6 +901,7 @@ class ConcatenatedModule extends Module {
 		this.rootModule = rootModule;
 		/** @type {Set<Module>} */
 		this._modules = modules;
+		/** @type {RuntimeSpec} */
 		this._runtime = runtime;
 		this.factoryMeta = rootModule && rootModule.factoryMeta;
 		/** @type {Compilation} */
@@ -848,9 +945,9 @@ class ConcatenatedModule extends Module {
 	 * @returns {string} a user readable identifier of the module
 	 */
 	readableIdentifier(requestShortener) {
-		return `${this.rootModule.readableIdentifier(
-			requestShortener
-		)} + ${this._modules.size - 1} modules`;
+		return `${this.rootModule.readableIdentifier(requestShortener)} + ${
+			this._modules.size - 1
+		} modules`;
 	}
 
 	/**
@@ -893,7 +990,7 @@ class ConcatenatedModule extends Module {
 		const { moduleArgument, exportsArgument } =
 			/** @type {BuildInfo} */
 			(rootModule.buildInfo);
-		/** @type {BuildInfo} */
+		/** @type {ConcatenatedModuleBuildInfo} */
 		this.buildInfo = {
 			strict: true,
 			cacheable: true,
@@ -903,7 +1000,10 @@ class ConcatenatedModule extends Module {
 			contextDependencies: new LazySet(),
 			missingDependencies: new LazySet(),
 			topLevelDeclarations: new Set(),
-			assets: undefined
+			assets: undefined,
+			inlineExports: /** @type {JavascriptModuleBuildInfo} */ (
+				rootModule.buildInfo
+			).inlineExports
 		};
 		this.buildMeta = rootModule.buildMeta;
 		this.clearDependenciesAndBlocks();
@@ -962,16 +1062,16 @@ class ConcatenatedModule extends Module {
 			}
 
 			const { assets, assetsInfo, topLevelDeclarations, needCreateRequire } =
-				/** @type {BuildInfo} */ (m.buildInfo);
+				/** @type {JavascriptModuleBuildInfo} */ (m.buildInfo);
 
 			const buildInfo = this.buildInfo;
 
 			// populate topLevelDeclarations
 			if (topLevelDeclarations) {
-				const topLevelDeclarations = buildInfo.topLevelDeclarations;
-				if (topLevelDeclarations !== undefined) {
+				const mergedTopLevelDeclarations = buildInfo.topLevelDeclarations;
+				if (mergedTopLevelDeclarations !== undefined) {
 					for (const decl of topLevelDeclarations) {
-						topLevelDeclarations.add(decl);
+						mergedTopLevelDeclarations.add(decl);
 					}
 				}
 			} else {
@@ -1351,6 +1451,11 @@ class ConcatenatedModule extends Module {
 		/** @type {NeededNamespaceObjects} */
 		const neededNamespaceObjects = new Set();
 
+		// Set with modules whose mangled namespace escapes as a whole value and
+		// therefore needs a decoupled namespace object keyed by the original names
+		/** @type {Set<ConcatenatedModuleInfo | ExternalModuleInfo>} */
+		const neededEscapeNamespaceObjects = new Set();
+
 		// List of all used names to avoid conflicts
 		const allUsedNames = new Set(RESERVED_NAMES);
 
@@ -1376,14 +1481,66 @@ class ConcatenatedModule extends Module {
 		/** @type {TopLevelDeclarations} */
 		const topLevelDeclarations = new Set();
 
+		// Free names remaining in the rendered source (runtime globals are
+		// tracked by runtimeRequirements instead)
+		/** @type {Set<string>} */
+		const freeNames = new Set();
+
 		// List of additional names in scope for module references
-		/** @type {Map<string, ScopeInfo>} */
+		/** @type {UsedNamesInScopeInfo} */
 		const usedNamesInScopeInfo = new Map();
 
 		// Set of already checked scopes
 		/** @type {Set<Scope>} */
 		const ignoredScopes = new Set();
 
+		/**
+		 * Lazily allocates a decoupled namespace object for a concatenated module
+		 * whose exports are mangled, so an escaping whole-namespace value still
+		 * exposes the original export names. Returns undefined when no export is
+		 * mangled (the regular namespace object can be used as-is).
+		 * @param {ConcatenatedModuleInfo | ExternalModuleInfo} info module info
+		 * @returns {string | undefined} the escape namespace object name
+		 */
+		const getEscapeNamespaceObjectName = (info) => {
+			if (info.type === "concatenated" && info.namespaceExportSymbol) {
+				return undefined;
+			}
+			// Deferred external modules keep their special deferred namespace object
+			// and are rendered through a different path that wouldn't emit ours.
+			if (info.type === "external" && info.deferred) return undefined;
+			// Only real ES module namespaces are decoupled; non-harmony modules use
+			// their interop/fake namespace object as before.
+			const buildMeta = /** @type {BuildMeta} */ (info.module.buildMeta);
+			if (!buildMeta || buildMeta.exportsType !== "namespace") return undefined;
+			if (info.escapeNamespaceObjectName !== undefined) {
+				return info.escapeNamespaceObjectName;
+			}
+			const exportsInfo = moduleGraph.getExportsInfo(info.module);
+			let mangled = false;
+			for (const exportInfo of exportsInfo.orderedExports) {
+				if (exportInfo.provided === false) continue;
+				const usedName = exportInfo.getUsedName(undefined, runtime);
+				if (!usedName || usedName instanceof InlinedUsedName) continue;
+				if (usedName[usedName.length - 1] !== exportInfo.name) {
+					mangled = true;
+					break;
+				}
+			}
+			if (!mangled) return undefined;
+			const name = findNewName(
+				"namespaceObject",
+				allUsedNames,
+				/** @type {UsedNames} */ (new Set()),
+				info.module.readableIdentifier(requestShortener)
+			);
+			allUsedNames.add(name);
+			topLevelDeclarations.add(name);
+			info.escapeNamespaceObjectName = name;
+			neededEscapeNamespaceObjects.add(info);
+			return name;
+		};
+
 		// get all global names
 		for (const info of modulesWithInfo) {
 			if (info.type === "concatenated") {
@@ -1436,6 +1593,18 @@ class ConcatenatedModule extends Module {
 							if (referencedInfo.type === "reference") {
 								throw new Error("Module reference can't point to a reference");
 							}
+							// An escaping mangled namespace resolves to its own decoupled
+							// namespace object (a unique top-level name), so it neither needs
+							// the regular namespace object nor super-class scope handling.
+							if (
+								match.mangleableNamespace &&
+								match.ids.length === 0 &&
+								(referencedInfo.type === "concatenated" ||
+									referencedInfo.type === "external") &&
+								getEscapeNamespaceObjectName(referencedInfo) !== undefined
+							) {
+								continue;
+							}
 							const binding = getFinalBinding(
 								moduleGraph,
 								referencedInfo,
@@ -1478,6 +1647,7 @@ class ConcatenatedModule extends Module {
 							);
 						} else {
 							allUsedNames.add(name);
+							freeNames.add(name);
 						}
 					}
 				}
@@ -1745,22 +1915,35 @@ class ConcatenatedModule extends Module {
 								concatenationScope.setRawExportMap(exportId, newName);
 							}
 						}
-						const finalName = getFinalName(
-							moduleGraph,
-							referencedInfo,
-							match.ids,
-							moduleToInfoMap,
-							runtime,
-							requestShortener,
-							runtimeTemplate,
-							neededNamespaceObjects,
-							match.call,
-							match.deferredImport,
-							!match.directImport,
-							/** @type {BuildMeta} */
-							(info.module.buildMeta).strictHarmonyModule,
-							match.asiSafe
-						);
+						// A whole-namespace value that escapes: when the module's exports
+						// are mangled, point it at a decoupled namespace object that keeps
+						// the original names so untracked access keeps working.
+						const escapeName =
+							match.mangleableNamespace &&
+							match.ids.length === 0 &&
+							(referencedInfo.type === "concatenated" ||
+								referencedInfo.type === "external")
+								? getEscapeNamespaceObjectName(referencedInfo)
+								: undefined;
+						const finalName =
+							escapeName !== undefined
+								? escapeName
+								: getFinalName(
+										moduleGraph,
+										referencedInfo,
+										match.ids,
+										moduleToInfoMap,
+										runtime,
+										requestShortener,
+										runtimeTemplate,
+										neededNamespaceObjects,
+										match.call,
+										match.deferredImport,
+										!match.directImport,
+										/** @type {BuildMeta} */
+										(info.module.buildMeta).strictHarmonyModule,
+										match.asiSafe
+									);
 
 						for (const reference of references) {
 							const r = /** @type {Range} */ (reference.identifier.range);
@@ -1780,6 +1963,9 @@ class ConcatenatedModule extends Module {
 		// Set with all root exposed unused exports
 		/** @type {Set<string>} */
 		const unusedExports = new Set();
+		// Set with all root exposed exports that were substituted with inlined literals
+		/** @type {Set<string>} */
+		const inlinedExports = new Set();
 
 		const rootInfo =
 			/** @type {ConcatenatedModuleInfo} */
@@ -1798,6 +1984,10 @@ class ConcatenatedModule extends Module {
 				unusedExports.add(name);
 				continue;
 			}
+			if (used instanceof InlinedUsedName) {
+				inlinedExports.add(name);
+				continue;
+			}
 			exportsMap.set(used, (requestShortener) => {
 				try {
 					const finalName = getFinalName(
@@ -1868,9 +2058,9 @@ class ConcatenatedModule extends Module {
 
 			const exportsSource =
 				"\n// EXPORTS\n" +
-				`${RuntimeGlobals.definePropertyGetters}(${this.exportsArgument}, {${definitions.join(
-					","
-				)}\n});\n`;
+				`${RuntimeGlobals.definePropertyGetters}(${
+					this.exportsArgument
+				}, {${definitions.join(",")}\n});\n`;
 
 			const { onDemandExportsGeneration } =
 				ConcatenatedModule.getCompilationHooks(this.compilation);
@@ -1894,6 +2084,87 @@ class ConcatenatedModule extends Module {
 			);
 		}
 
+		// list inlined exports
+		if (inlinedExports.size > 0) {
+			result.add(
+				`\n// INLINED EXPORTS: ${joinIterableWithComma(inlinedExports)}\n`
+			);
+		}
+
+		// generate decoupled namespace objects for escaping mangled namespaces:
+		// same getters as the regular namespace object, but keyed by the original
+		// export names so untracked access by name keeps working. Done before the
+		// regular namespace objects so any nested namespace they pull in is built.
+		/** @type {Map<ConcatenatedModuleInfo | ExternalModuleInfo, string>} */
+		const escapeNamespaceObjectSources = new Map();
+		for (const info of neededEscapeNamespaceObjects) {
+			/** @type {string[]} */
+			const nsObj = [];
+			const exportsInfo = moduleGraph.getExportsInfo(info.module);
+			for (const exportInfo of exportsInfo.orderedExports) {
+				if (exportInfo.provided === false) continue;
+				const usedName = exportInfo.getUsedName(undefined, runtime);
+				if (!usedName) continue;
+				if (usedName instanceof InlinedUsedName) {
+					nsObj.push(
+						`\n  ${propertyName(exportInfo.name)}: ${runtimeTemplate.returningFunction(
+							usedName.render(
+								Template.toNormalComment(
+									`inlined export ${propertyAccess(exportInfo.name)}`
+								)
+							)
+						)}`
+					);
+				} else {
+					// External (non-concatenated) modules are accessed through their
+					// import variable; concatenated ones resolve to an internal binding.
+					const finalName =
+						info.type === "external"
+							? `${/** @type {string} */ (info.name)}${propertyAccess(usedName)}`
+							: getFinalName(
+									moduleGraph,
+									info,
+									[exportInfo.name],
+									moduleToInfoMap,
+									runtime,
+									requestShortener,
+									runtimeTemplate,
+									neededNamespaceObjects,
+									false,
+									false,
+									undefined,
+									/** @type {BuildMeta} */
+									(info.module.buildMeta).strictHarmonyModule,
+									true
+								);
+					nsObj.push(
+						`\n  ${propertyName(exportInfo.name)}: ${runtimeTemplate.returningFunction(
+							finalName
+						)}`
+					);
+				}
+			}
+			const name = /** @type {string} */ (info.escapeNamespaceObjectName);
+			const defineGetters =
+				nsObj.length > 0
+					? `${RuntimeGlobals.definePropertyGetters}(${name}, {${nsObj.join(
+							","
+						)}\n});\n`
+					: "";
+			if (nsObj.length > 0) {
+				runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
+			}
+			escapeNamespaceObjectSources.set(
+				info,
+				`
+// NAMESPACE OBJECT (decoupled): ${info.module.readableIdentifier(requestShortener)}
+var ${name} = {};
+${RuntimeGlobals.makeNamespaceObject}(${name});
+${defineGetters}`
+			);
+			runtimeRequirements.add(RuntimeGlobals.makeNamespaceObject);
+		}
+
 		// generate namespace objects
 		/** @type {Map<ConcatenatedModuleInfo, string>} */
 		const namespaceObjectSources = new Map();
@@ -1906,27 +2177,40 @@ class ConcatenatedModule extends Module {
 				if (exportInfo.provided === false) continue;
 				const usedName = exportInfo.getUsedName(undefined, runtime);
 				if (usedName) {
-					const finalName = getFinalName(
-						moduleGraph,
-						info,
-						[exportInfo.name],
-						moduleToInfoMap,
-						runtime,
-						requestShortener,
-						runtimeTemplate,
-						neededNamespaceObjects,
-						false,
-						false,
-						undefined,
-						/** @type {BuildMeta} */
-						(info.module.buildMeta).strictHarmonyModule,
-						true
-					);
-					nsObj.push(
-						`\n  ${propertyName(usedName)}: ${runtimeTemplate.returningFunction(
-							finalName
-						)}`
-					);
+					// TODO: Replace with the inlined value directly at the call site
+					if (usedName instanceof InlinedUsedName) {
+						nsObj.push(
+							`\n  ${propertyName(exportInfo.name)}: ${runtimeTemplate.returningFunction(
+								usedName.render(
+									Template.toNormalComment(
+										`inlined export ${propertyAccess(exportInfo.name)}`
+									)
+								)
+							)}`
+						);
+					} else {
+						const finalName = getFinalName(
+							moduleGraph,
+							info,
+							[exportInfo.name],
+							moduleToInfoMap,
+							runtime,
+							requestShortener,
+							runtimeTemplate,
+							neededNamespaceObjects,
+							false,
+							false,
+							undefined,
+							/** @type {BuildMeta} */
+							(info.module.buildMeta).strictHarmonyModule,
+							true
+						);
+						nsObj.push(
+							`\n  ${propertyName(usedName)}: ${runtimeTemplate.returningFunction(
+								finalName
+							)}`
+						);
+					}
 				}
 			}
 			const name = info.namespaceObjectName;
@@ -1954,16 +2238,21 @@ ${defineGetters}`
 		for (const info of modulesWithInfo) {
 			if (info.type === "concatenated") {
 				const source = namespaceObjectSources.get(info);
-				if (!source) continue;
-				result.add(source);
+				if (source) result.add(source);
+				const escapeSource = escapeNamespaceObjectSources.get(
+					/** @type {ConcatenatedModuleInfo} */ (info)
+				);
+				if (escapeSource) result.add(escapeSource);
+				if (!source && !escapeSource) continue;
 			}
 
 			if (info.type === "external" && info.deferred) {
 				const moduleId = JSON.stringify(chunkGraph.getModuleId(info.module));
 				const loader = getOptimizedDeferredModule(
 					moduleId,
-					info.module.getExportsType(
+					getExportsType(
 						moduleGraph,
+						info,
 						/** @type {BuildMeta} */
 						(this.rootModule.buildMeta).strictHarmonyModule
 					),
@@ -1973,7 +2262,9 @@ ${defineGetters}`
 				);
 				runtimeRequirements.add(RuntimeGlobals.require);
 				result.add(
-					`\n// DEFERRED EXTERNAL MODULE: ${info.module.readableIdentifier(requestShortener)}\nvar ${info.deferredName} = ${loader};`
+					`\n// DEFERRED EXTERNAL MODULE: ${info.module.readableIdentifier(
+						requestShortener
+					)}\nvar ${info.deferredName} = ${loader};`
 				);
 				if (info.deferredNamespaceObjectUsed) {
 					runtimeRequirements.add(RuntimeGlobals.makeDeferredNamespaceObject);
@@ -1983,7 +2274,7 @@ ${defineGetters}`
 						}(${JSON.stringify(
 							chunkGraph.getModuleId(info.module)
 						)}, ${getMakeDeferredNamespaceModeFromExportsType(
-							info.module.getExportsType(moduleGraph, strictHarmonyModule)
+							getExportsType(moduleGraph, info, strictHarmonyModule)
 						)});`
 					);
 				}
@@ -2041,8 +2332,15 @@ ${defineGetters}`
 						const moduleId = JSON.stringify(
 							chunkGraph.getModuleId(info.module)
 						);
+						// External module bindings may be wrapped in
+						// runtime-condition `if` blocks but referenced outside,
+						// so they must remain function-scoped (`var`).
 						result.add(`var ${info.name} = __webpack_require__(${moduleId});`);
 						name = info.name;
+						// Decoupled namespace object for an escaping mangled external
+						// module must come after its import variable is defined.
+						const escapeSource = escapeNamespaceObjectSources.get(info);
+						if (escapeSource) result.add(escapeSource);
 					}
 					// 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"),
@@ -2052,7 +2350,9 @@ ${defineGetters}`
 						(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;`
+							`\n// non-deferred import to a deferred module (${info.module.readableIdentifier(
+								requestShortener
+							)})\nvar ${info.name} = ${info.deferredName}.a;`
 						);
 					}
 					break;
@@ -2090,6 +2390,7 @@ ${defineGetters}`
 			data.set("chunkInitFragments", chunkInitFragments);
 		}
 		data.set("topLevelDeclarations", topLevelDeclarations);
+		data.set("freeNames", freeNames);
 
 		/** @type {CodeGenerationResult} */
 		const resultEntry = {
@@ -2135,7 +2436,8 @@ ${defineGetters}`
 					usedNames
 				);
 
-				// TODO cache codeGeneration results
+				// Not cached: Compilation memoizes the outer codeGeneration per
+				// (module, runtime), so inner generation never recomputes usefully.
 				const codeGenResult = m.codeGeneration({
 					dependencyTemplates,
 					runtimeTemplate,
@@ -2236,6 +2538,7 @@ ${defineGetters}`
 							module: info.module,
 							index,
 							ast: undefined,
+							chunkInitFragments: undefined,
 							internalSource: undefined,
 							runtimeRequirements: undefined,
 							source: undefined,
@@ -2246,13 +2549,16 @@ ${defineGetters}`
 							rawExportMap: undefined,
 							namespaceExportSymbol: undefined,
 							namespaceObjectName: undefined,
+							escapeNamespaceObjectName: undefined,
 							interopNamespaceObjectUsed: false,
 							interopNamespaceObjectName: undefined,
 							interopNamespaceObject2Used: false,
 							interopNamespaceObject2Name: undefined,
 							interopDefaultAccessUsed: false,
 							interopDefaultAccessName: undefined,
-							concatenationScope: undefined
+							concatenationScope: undefined,
+							exportsTypeStrict: undefined,
+							exportsTypeNonStrict: undefined
 						};
 						break;
 					case "external":
@@ -2263,6 +2569,7 @@ ${defineGetters}`
 							nonDeferAccess: info.nonDeferAccess,
 							index,
 							name: undefined,
+							escapeNamespaceObjectName: undefined,
 							deferredName: undefined,
 							interopNamespaceObjectUsed: false,
 							interopNamespaceObjectName: undefined,
@@ -2270,9 +2577,13 @@ ${defineGetters}`
 							interopNamespaceObject2Name: undefined,
 							interopDefaultAccessUsed: false,
 							interopDefaultAccessName: undefined,
-							deferred: moduleGraph.isDeferred(info.module),
+							deferred: this.compilation.options.experiments.deferImport
+								? moduleGraph.isDeferred(info.module)
+								: false,
 							deferredNamespaceObjectName: undefined,
-							deferredNamespaceObjectUsed: false
+							deferredNamespaceObjectUsed: false,
+							exportsTypeStrict: undefined,
+							exportsTypeNonStrict: undefined
 						};
 						break;
 					default:
@@ -2318,7 +2629,14 @@ ${defineGetters}`
 					break;
 				case "external":
 					hash.update(
-						`${chunkGraph.getModuleId(info.module)}|${runtimeConditionToString(info.runtimeCondition)}|${info.nonDeferAccess ? "1" : "0"}|${chunkGraph.moduleGraph.isDeferred(info.module) ? "1" : "0"}`
+						`${chunkGraph.getModuleId(info.module)}|${runtimeConditionToString(
+							info.runtimeCondition
+						)}|${info.nonDeferAccess ? "1" : "0"}|${
+							this.compilation.options.experiments.deferImport &&
+							chunkGraph.moduleGraph.isDeferred(info.module)
+								? "1"
+								: "0"
+						}`
 					);
 					break;
 			}