@depup/webpack 5.106.1-depup.0 → 5.109.2-depup.0

package/lib/optimize/ConcatenatedModule.js

@@ -14,6 +14,7 @@ const {
 	ReplaceSource
 } = require("webpack-sources");
 const ConcatenationScope = require("../ConcatenationScope");
+const Dependency = require("../Dependency");
 const { UsageState } = require("../ExportsInfo");
 const Module = require("../Module");
 const {
@@ -24,10 +25,12 @@ 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 { isCommonJsWrapped } = require("../javascript/JavascriptGenerator");
 const JavascriptParser = require("../javascript/JavascriptParser");
 const {
+	getDeferredCycleModuleIds,
+	getDeferredCycleModules,
 	getMakeDeferredNamespaceModeFromExportsType,
 	getOptimizedDeferredModule
 } = require("../runtime/MakeDeferredNamespaceObjectRuntime");
@@ -43,6 +46,7 @@ const {
 	getUsedNamesInScopeInfo
 } = require("../util/concatenate");
 const createHash = require("../util/createHash");
+const createHooksRegistry = require("../util/createHooksRegistry");
 const { makePathsRelative } = require("../util/identifier");
 const makeSerializable = require("../util/makeSerializable");
 const { propertyAccess, propertyName } = require("../util/property");
@@ -54,22 +58,23 @@ const {
 	runtimeConditionToString,
 	subtractRuntimeCondition
 } = require("../util/runtime");
+const { InlinedUsedName } = require("./InlineExports");
 
-/** @typedef {import("eslint-scope").Reference} Reference */
-/** @typedef {import("eslint-scope").Scope} Scope */
-/** @typedef {import("eslint-scope").Variable} Variable */
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../dependencies/ModuleDependency")} ModuleDependency */
+/** @typedef {import("../dependencies/HarmonyImportDependency")} HarmonyImportDependency */
 /** @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").ExportsType} ExportsType */
 /** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("../Module").CodeGenerationResultData} CodeGenerationResultData */
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
@@ -80,19 +85,26 @@ const {
 /** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../NormalModule")} NormalModule */
 /** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @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 */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").Variable} Variable */
 /** @typedef {import("../javascript/JavascriptParser").Program} Program */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("estree").Identifier} Identifier */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @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 */
@@ -146,6 +158,7 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
  * @property {"concatenated"} type
  * @property {Module} module
  * @property {number} index
+ * @property {boolean=} cjsWrapped a "weird" CommonJS module executed via the CJS wrapper runtime helper with real module/exports objects
  * @property {Program | undefined} ast
  * @property {Source | undefined} internalSource
  * @property {ReplaceSource | undefined} source
@@ -158,6 +171,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
@@ -165,6 +179,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)
  */
 
 /**
@@ -175,6 +191,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
@@ -185,6 +202,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)
  */
 
 /**
@@ -280,6 +299,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
@@ -293,7 +333,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 = (
@@ -309,12 +349,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 &&
@@ -323,6 +360,9 @@ const getFinalBinding = (
 	if (exportName.length === 0) {
 		switch (exportsType) {
 			case "default-only":
+				// a concatenated CommonJS module has no runtime exports object;
+				// its fake namespace is built over the generated namespace object
+				if (info.type === "concatenated") neededNamespaceObjects.add(info);
 				if (deferred) info.deferredNamespaceObjectUsed = true;
 				else info.interopNamespaceObject2Used = true;
 				return {
@@ -336,6 +376,7 @@ const getFinalBinding = (
 					exportName
 				};
 			case "default-with-named":
+				if (info.type === "concatenated") neededNamespaceObjects.add(info);
 				if (deferred) info.deferredNamespaceObjectUsed = true;
 				else info.interopNamespaceObjectUsed = true;
 				return {
@@ -362,6 +403,20 @@ const getFinalBinding = (
 				switch (exportName[0]) {
 					case "default":
 						exportName = exportName.slice(1);
+						if (deferred) {
+							// `ns.default` for a deferred default-with-named external
+							// module must read through the optimized `.a` getter
+							// (which lazily evaluates the module and returns its
+							// exports), not the proxy namespace itself — otherwise
+							// `typeof ns.default` / `ns.default instanceof X`
+							// observe the proxy instead of the actual default.
+							return {
+								info,
+								rawName: `${info.deferredName}.a`,
+								ids: exportName,
+								exportName
+							};
+						}
 						break;
 					case "__esModule":
 						return {
@@ -392,6 +447,18 @@ const getFinalBinding = (
 						exportName
 					};
 				}
+				if (deferred) {
+					// As with default-with-named above, `ns.default` for a
+					// deferred default-only external must read through the
+					// optimized `.a` getter so that `typeof` / `instanceof`
+					// observe the actual default value rather than the proxy.
+					return {
+						info,
+						rawName: `${info.deferredName}.a`,
+						ids: exportName,
+						exportName
+					};
+				}
 				break;
 			}
 			case "dynamic":
@@ -476,6 +543,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,
@@ -500,9 +570,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,
@@ -511,10 +579,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
 				};
 			}
@@ -531,6 +615,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
@@ -562,7 +667,9 @@ const getFinalBinding = (
 					alreadyVisited
 				);
 			}
-			if (info.namespaceExportSymbol) {
+			// A wrapped module resolves every export through its live exports
+			// alias (namespaceObjectName), same as namespaceExportSymbol modules.
+			if (info.namespaceExportSymbol || info.cjsWrapped) {
 				const usedName = /** @type {ExportName} */ (
 					exportsInfo.getUsedName(exportName, runtime)
 				);
@@ -581,9 +688,7 @@ const getFinalBinding = (
 		}
 
 		case "external": {
-			const used = /** @type {ExportName} */ (
-				exportsInfo.getUsedName(exportName, runtime)
-			);
+			const used = exportsInfo.getUsedName(exportName, runtime);
 			if (!used) {
 				return {
 					info,
@@ -592,7 +697,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 {
@@ -601,7 +720,7 @@ const getFinalBinding = (
 					(deferred ? info.deferredName : info.name) +
 					(deferred ? ".a" : "") +
 					comment,
-				ids: used,
+				ids: usedName,
 				exportName
 			};
 		}
@@ -699,8 +818,17 @@ const getFinalName = (
 
 /** @typedef {BuildInfo["topLevelDeclarations"]} TopLevelDeclarations */
 
-/** @type {WeakMap<Compilation, ConcatenateModuleHooks>} */
-const compilationHooksMap = new WeakMap();
+/**
+ * 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 */
 
 class ConcatenatedModule extends Module {
 	/**
@@ -735,30 +863,6 @@ class ConcatenatedModule extends Module {
 		});
 	}
 
-	/**
-	 * @param {Compilation} compilation the compilation
-	 * @returns {ConcatenateModuleHooks} the attached hooks
-	 */
-	static getCompilationHooks(compilation) {
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				onDemandExportsGeneration: new SyncBailHook([
-					"module",
-					"runtimes",
-					"exportsFinalName",
-					"exportsSource"
-				]),
-				concatenatedModuleInfo: new SyncBailHook([
-					"updatedInfo",
-					"concatenatedModuleInfo"
-				])
-			};
-			compilationHooksMap.set(compilation, hooks);
-		}
-		return hooks;
-	}
-
 	/**
 	 * @param {object} options options
 	 * @param {string} options.identifier the identifier of the module
@@ -770,6 +874,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;
@@ -777,6 +887,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} */
@@ -795,6 +906,7 @@ class ConcatenatedModule extends Module {
 	}
 
 	/**
+	 * Returns the source types this module can generate.
 	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
@@ -806,6 +918,7 @@ class ConcatenatedModule extends Module {
 	}
 
 	/**
+	 * Returns the unique identifier used to reference this module.
 	 * @returns {string} a unique identifier of the module
 	 */
 	identifier() {
@@ -813,16 +926,18 @@ class ConcatenatedModule extends Module {
 	}
 
 	/**
+	 * Returns a human-readable identifier for this module.
 	 * @param {RequestShortener} requestShortener the request shortener
 	 * @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`;
 	}
 
 	/**
+	 * Gets the library identifier.
 	 * @param {LibIdentOptions} options options
 	 * @returns {LibIdent | null} an identifier for library inclusion
 	 */
@@ -831,6 +946,7 @@ class ConcatenatedModule extends Module {
 	}
 
 	/**
+	 * Returns the path used when matching this module against rule conditions.
 	 * @returns {NameForCondition | null} absolute path which should be used for condition matching (usually the resource path)
 	 */
 	nameForCondition() {
@@ -838,6 +954,7 @@ class ConcatenatedModule extends Module {
 	}
 
 	/**
+	 * Gets side effects connection state.
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @returns {ConnectionState} how this module should be connected to referencing modules when consumed for side-effects only
 	 */
@@ -846,6 +963,7 @@ class ConcatenatedModule extends Module {
 	}
 
 	/**
+	 * Builds the module using the provided compilation context.
 	 * @param {WebpackOptions} options webpack options
 	 * @param {Compilation} compilation the compilation
 	 * @param {ResolverWithOptions} resolver the resolver
@@ -858,7 +976,7 @@ class ConcatenatedModule extends Module {
 		const { moduleArgument, exportsArgument } =
 			/** @type {BuildInfo} */
 			(rootModule.buildInfo);
-		/** @type {BuildInfo} */
+		/** @type {ConcatenatedModuleBuildInfo} */
 		this.buildInfo = {
 			strict: true,
 			cacheable: true,
@@ -868,7 +986,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();
@@ -876,20 +997,46 @@ class ConcatenatedModule extends Module {
 
 		for (const m of this._modules) {
 			// populate cacheable
-			if (!(/** @type {BuildInfo} */ (m.buildInfo).cacheable)) {
+			const { cacheable, notCacheableReasons } = /** @type {BuildInfo} */ (
+				m.buildInfo
+			);
+			if (!cacheable) {
 				this.buildInfo.cacheable = false;
+				if (notCacheableReasons) {
+					const reasons =
+						this.buildInfo.notCacheableReasons ||
+						(this.buildInfo.notCacheableReasons = []);
+					for (const reason of notCacheableReasons) {
+						if (!reasons.includes(reason)) reasons.push(reason);
+					}
+				}
 			}
 
-			// populate dependencies
-			for (const d of m.dependencies.filter(
-				(dep) =>
-					!(dep instanceof HarmonyImportDependency) ||
+			// populate dependencies — keep only deps that leave the concat set
+			for (const d of m.dependencies) {
+				if (
+					!Dependency.canConcatenate(d) ||
 					!this._modules.has(
 						/** @type {Module} */
-						(compilation.moduleGraph.getModule(dep))
+						(compilation.moduleGraph.getModule(d))
 					)
-			)) {
-				this.dependencies.push(d);
+				) {
+					this.dependencies.push(d);
+				}
+			}
+			// populate codeGenerationDependencies — the inner modules'
+			// templates are applied during ConcatenatedModule.codeGeneration,
+			// so the referenced modules must have been code-generated by then.
+			// Skip references that point back into the concat set itself.
+			if (m.codeGenerationDependencies !== undefined) {
+				for (const d of m.codeGenerationDependencies) {
+					const referenced =
+						/** @type {Module} */
+						(compilation.moduleGraph.getModule(d));
+					if (!this._modules.has(referenced)) {
+						this.addCodeGenerationDependency(d);
+					}
+				}
 			}
 			// populate blocks
 			for (const d of m.blocks) {
@@ -913,16 +1060,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 {
@@ -958,6 +1105,7 @@ class ConcatenatedModule extends Module {
 	}
 
 	/**
+	 * Returns the estimated size for the requested source type.
 	 * @param {string=} type the source type for which the size should be estimated
 	 * @returns {number} the estimated size of the module (must be non-zero)
 	 */
@@ -1000,7 +1148,10 @@ class ConcatenatedModule extends Module {
 			 */
 			const references = connections
 				.filter((connection) => {
-					if (!(connection.dependency instanceof HarmonyImportDependency)) {
+					if (
+						!connection.dependency ||
+						!Dependency.canConcatenate(connection.dependency)
+					) {
 						return false;
 					}
 					if (
@@ -1243,6 +1394,7 @@ class ConcatenatedModule extends Module {
 	}
 
 	/**
+	 * Adds the provided file dependencies to the module.
 	 * @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
@@ -1265,6 +1417,7 @@ class ConcatenatedModule extends Module {
 	}
 
 	/**
+	 * Generates code and runtime requirements for this module.
 	 * @param {CodeGenerationContext} context context for code generation
 	 * @returns {CodeGenerationResult} result
 	 */
@@ -1296,6 +1449,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);
 
@@ -1321,17 +1479,69 @@ 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") {
+			if (info.type === "concatenated" && !info.cjsWrapped) {
 				// ignore symbols from moduleScope
 				if (info.moduleScope) {
 					ignoredScopes.add(info.moduleScope);
@@ -1381,6 +1591,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,
@@ -1423,6 +1645,7 @@ class ConcatenatedModule extends Module {
 							);
 						} else {
 							allUsedNames.add(name);
+							freeNames.add(name);
 						}
 					}
 				}
@@ -1508,6 +1731,23 @@ class ConcatenatedModule extends Module {
 			);
 			switch (info.type) {
 				case "concatenated": {
+					if (info.cjsWrapped) {
+						// Wrapped modules expose one shared-scope name: the final
+						// exports object used as the namespace.
+						const namespaceObjectName = findNewName(
+							"namespaceObject",
+							allUsedNames,
+							namespaceObjectUsedNames,
+							info.module.readableIdentifier(requestShortener)
+						);
+						allUsedNames.add(namespaceObjectName);
+						topLevelDeclarations.add(namespaceObjectName);
+						info.namespaceObjectName = namespaceObjectName;
+						// Route every binding to the live exports alias and skip the
+						// materialized namespace object generated for other modules.
+						info.namespaceExportSymbol = namespaceObjectName;
+						break;
+					}
 					const variables = /** @type {Scope} */ (info.moduleScope).variables;
 					for (const variable of variables) {
 						const name = variable.name;
@@ -1515,10 +1755,12 @@ class ConcatenatedModule extends Module {
 						const newName = _findNewName(name, info, references);
 						if (newName) {
 							const source = /** @type {ReplaceSource} */ (info.source);
-							const allIdentifiers = new Set([
-								...references.map((r) => r.identifier),
-								...variable.identifiers
-							]);
+							/** @type {Set<Identifier>} */
+							const allIdentifiers = new Set();
+							for (const r of references) allIdentifiers.add(r.identifier);
+							for (const identifier of variable.identifiers) {
+								allIdentifiers.add(identifier);
+							}
 							for (const identifier of allIdentifiers) {
 								const r = /** @type {Range} */ (identifier.range);
 								const path = getPathInAst(
@@ -1644,18 +1886,18 @@ class ConcatenatedModule extends Module {
 
 		// Find and replace references to modules
 		for (const info of moduleToInfoMap.values()) {
-			if (info.type === "concatenated") {
+			if (info.type === "concatenated" && !info.cjsWrapped) {
 				const globalScope = /** @type {Scope} */ (info.globalScope);
 				// group references by name
 				/** @type {Map<string, Reference[]>} */
 				const referencesByName = new Map();
 				for (const reference of globalScope.through) {
 					const name = reference.identifier.name;
-					if (!referencesByName.has(name)) {
-						referencesByName.set(name, []);
+					let references = referencesByName.get(name);
+					if (references === undefined) {
+						referencesByName.set(name, (references = []));
 					}
-					/** @type {Reference[]} */
-					(referencesByName.get(name)).push(reference);
+					references.push(reference);
 				}
 				for (const [name, references] of referencesByName) {
 					const match = ConcatenationScope.matchModuleReference(name);
@@ -1690,22 +1932,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);
@@ -1725,6 +1980,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} */
@@ -1743,6 +2001,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(
@@ -1813,9 +2075,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);
@@ -1839,6 +2101,93 @@ 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();
@@ -1851,27 +2200,42 @@ 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;
@@ -1899,26 +2263,43 @@ ${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
 					),
 					// an async module will opt-out of the concat module optimization.
 					[],
+					// A closure member absorbed into this concatenation shares this
+					// module's runtime id (and thus its `evaluating` flag); resolve it
+					// to that id instead of the member's now-absent standalone id.
+					getDeferredCycleModuleIds(
+						getDeferredCycleModules(moduleGraph, info.module),
+						(mod) =>
+							moduleToInfoMap.has(mod)
+								? chunkGraph.getModuleId(this)
+								: chunkGraph.getModuleId(mod)
+					),
 					runtimeRequirements
 				);
 				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);
@@ -1928,7 +2309,7 @@ ${defineGetters}`
 						}(${JSON.stringify(
 							chunkGraph.getModuleId(info.module)
 						)}, ${getMakeDeferredNamespaceModeFromExportsType(
-							info.module.getExportsType(moduleGraph, strictHarmonyModule)
+							getExportsType(moduleGraph, info, strictHarmonyModule)
 						)});`
 					);
 				}
@@ -1949,7 +2330,18 @@ ${defineGetters}`
 					result.add(
 						`\n;// ${info.module.readableIdentifier(requestShortener)}\n`
 					);
-					result.add(/** @type {ReplaceSource} */ (info.source));
+					if (info.cjsWrapped) {
+						// Real CommonJS semantics via the runtime helper: it calls the
+						// body with this = exports and returns the final module.exports.
+						runtimeRequirements.add(RuntimeGlobals.commonJsWrap);
+						result.add(
+							`var ${info.namespaceObjectName} = /*#__PURE__*/${RuntimeGlobals.commonJsWrap}(function(${info.module.moduleArgument}, ${info.module.exportsArgument}) {\n`
+						);
+						result.add(/** @type {ReplaceSource} */ (info.source));
+						result.add("\n});\n");
+					} else {
+						result.add(/** @type {ReplaceSource} */ (info.source));
+					}
 					if (info.chunkInitFragments) {
 						for (const f of info.chunkInitFragments) chunkInitFragments.push(f);
 					}
@@ -1986,8 +2378,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"),
@@ -1997,7 +2396,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;
@@ -2035,6 +2436,7 @@ ${defineGetters}`
 			data.set("chunkInitFragments", chunkInitFragments);
 		}
 		data.set("topLevelDeclarations", topLevelDeclarations);
+		data.set("freeNames", freeNames);
 
 		/** @type {CodeGenerationResult} */
 		const resultEntry = {
@@ -2073,6 +2475,33 @@ ${defineGetters}`
 		if (info.type === "concatenated") {
 			const m = info.module;
 			try {
+				if (info.cjsWrapped) {
+					// A wrapped module renders its normal module source (real
+					// module/exports objects, own module ids) inside an IIFE, so it
+					// needs no concatenation scope, reference rewriting, or scope
+					// analysis — the wrapper isolates its top-level declarations.
+					const codeGenResult = m.codeGeneration({
+						dependencyTemplates,
+						runtimeTemplate,
+						moduleGraph,
+						chunkGraph,
+						runtime,
+						runtimes,
+						codeGenerationResults,
+						sourceTypes: JAVASCRIPT_TYPES
+					});
+					const source =
+						/** @type {Source} */
+						(codeGenResult.sources.get(JAVASCRIPT_TYPE));
+					const data = codeGenResult.data;
+					info.runtimeRequirements =
+						/** @type {ReadOnlyRuntimeRequirements} */
+						(codeGenResult.runtimeRequirements);
+					info.internalSource = source;
+					info.source = new ReplaceSource(source);
+					info.chunkInitFragments = data && data.get("chunkInitFragments");
+					return;
+				}
 				// Create a concatenation scope to track and capture information
 				const concatenationScope = new ConcatenationScope(
 					modulesMap,
@@ -2080,7 +2509,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,
@@ -2103,11 +2533,17 @@ ${defineGetters}`
 				let ast;
 
 				try {
+					const { experiments } = this.compilation.options;
+
 					({ ast } = JavascriptParser._parse(
 						code,
 						{
 							sourceType: "module",
-							ranges: true
+							ranges: true,
+							// generated code contains phase imports when the experiments are on
+							importPhases: Boolean(
+								experiments.deferImport || experiments.sourceImport
+							)
 						},
 						JavascriptParser._getModuleParseFunction(this.compilation, m)
 					));
@@ -2180,7 +2616,11 @@ ${defineGetters}`
 							type: "concatenated",
 							module: info.module,
 							index,
+							cjsWrapped: isCommonJsWrapped(
+								/** @type {NormalModule} */ (info.module)
+							),
 							ast: undefined,
+							chunkInitFragments: undefined,
 							internalSource: undefined,
 							runtimeRequirements: undefined,
 							source: undefined,
@@ -2191,13 +2631,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":
@@ -2208,6 +2651,7 @@ ${defineGetters}`
 							nonDeferAccess: info.nonDeferAccess,
 							index,
 							name: undefined,
+							escapeNamespaceObjectName: undefined,
 							deferredName: undefined,
 							interopNamespaceObjectUsed: false,
 							interopNamespaceObjectName: undefined,
@@ -2215,9 +2659,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:
@@ -2244,6 +2692,7 @@ ${defineGetters}`
 	}
 
 	/**
+	 * Updates the hash with the data contributed by this instance.
 	 * @param {Hash} hash the hash used to track dependencies
 	 * @param {UpdateHashContext} context context
 	 * @returns {void}
@@ -2261,8 +2710,16 @@ ${defineGetters}`
 					info.module.updateHash(hash, context);
 					break;
 				case "external":
-					hash.update(`${chunkGraph.getModuleId(info.module)}`);
-					// TODO runtimeCondition
+					hash.update(
+						`${chunkGraph.getModuleId(info.module)}|${runtimeConditionToString(
+							info.runtimeCondition
+						)}|${info.nonDeferAccess ? "1" : "0"}|${
+							this.compilation.options.experiments.deferImport &&
+							chunkGraph.moduleGraph.isDeferred(info.module)
+								? "1"
+								: "0"
+						}`
+					);
 					break;
 			}
 		}
@@ -2286,6 +2743,22 @@ ${defineGetters}`
 	}
 }
 
+ConcatenatedModule.getCompilationHooks = createHooksRegistry(
+	() =>
+		/** @type {ConcatenateModuleHooks} */ ({
+			onDemandExportsGeneration: new SyncBailHook([
+				"module",
+				"runtimes",
+				"exportsFinalName",
+				"exportsSource"
+			]),
+			concatenatedModuleInfo: new SyncBailHook([
+				"updatedInfo",
+				"concatenatedModuleInfo"
+			])
+		})
+);
+
 makeSerializable(ConcatenatedModule, "webpack/lib/optimize/ConcatenatedModule");
 
 module.exports = ConcatenatedModule;