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

package/lib/optimize/ConcatenatedModule.js

@@ -5,8 +5,6 @@
 
 "use strict";
 
-const eslintScope = require("eslint-scope");
-const Referencer = require("eslint-scope/lib/referencer");
 const { SyncBailHook } = require("tapable");
 const {
 	CachedSource,
@@ -16,18 +14,23 @@ const {
 const ConcatenationScope = require("../ConcatenationScope");
 const Dependency = require("../Dependency");
 const { UsageState } = require("../ExportsInfo");
+const ExternalModule = require("../ExternalModule");
 const Module = require("../Module");
 const {
 	JAVASCRIPT_TYPE,
 	JAVASCRIPT_TYPES
 } = require("../ModuleSourceTypeConstants");
 const { JAVASCRIPT_MODULE_TYPE_ESM } = require("../ModuleTypeConstants");
+const NormalModule = require("../NormalModule");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const { DEFAULTS } = require("../config/defaults");
+const CommonJsExportRequireDependency = require("../dependencies/CommonJsExportRequireDependency");
+const CommonJsFullRequireDependency = require("../dependencies/CommonJsFullRequireDependency");
+const CommonJsRequireDependency = require("../dependencies/CommonJsRequireDependency");
 const { ImportPhaseUtils } = require("../dependencies/ImportPhase");
-const { isCommonJsWrapped } = require("../javascript/JavascriptGenerator");
 const JavascriptParser = require("../javascript/JavascriptParser");
+const analyzeScope = require("../javascript/ScopeAnalyzer");
 const {
 	getDeferredCycleModuleIds,
 	getDeferredCycleModules,
@@ -36,14 +39,18 @@ const {
 } = require("../runtime/MakeDeferredNamespaceObjectRuntime");
 const { equals } = require("../util/ArrayHelpers");
 const LazySet = require("../util/LazySet");
-const { concatComparators } = require("../util/comparators");
+const {
+	compareModulesByFullName,
+	concatComparators
+} = require("../util/comparators");
 const {
 	RESERVED_NAMES,
 	addScopeSymbols,
 	findNewName,
 	getAllReferences,
 	getPathInAst,
-	getUsedNamesInScopeInfo
+	getUsedNamesInScopeInfo,
+	isCommonJsConcatenationEnabled
 } = require("../util/concatenate");
 const createHash = require("../util/createHash");
 const createHooksRegistry = require("../util/createHooksRegistry");
@@ -60,54 +67,71 @@ const {
 } = require("../util/runtime");
 const { InlinedUsedName } = require("./InlineExports");
 
-/** @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 */
-/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
-/** @typedef {import("../Module").LibIdent} LibIdent */
-/** @typedef {import("../Module").NameForCondition} NameForCondition */
-/** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
-/** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
-/** @typedef {import("../Module").SourceTypes} SourceTypes */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../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").UsedNamesInScopeInfo} UsedNamesInScopeInfo */
-/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
-/** @typedef {import("../util/identifier").AssociatedObjectForCache} AssociatedObjectForCache */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @import { Source } from "webpack-sources" */
+/**
+ * @import {
+ * 	WebpackOptionsNormalizedWithDefaults as WebpackOptions
+ * } from "../config/defaults"
+ */
+/** @import ChunkGraph from "../ChunkGraph" */
+/** @import CodeGenerationResults from "../CodeGenerationResults" */
+/** @import Compilation, { FileSystemDependencies } from "../Compilation" */
+/** @import { UpdateHashContext } from "../Dependency" */
+/** @import HarmonyImportDependency from "../dependencies/HarmonyImportDependency" */
+/** @import DependencyTemplates from "../DependencyTemplates" */
+/** @import { ExportInfo } from "../ExportsInfo" */
+/**
+ * @import {
+ * 	BuildCallback,
+ * 	BuildInfo,
+ * 	BuildMeta,
+ * 	ExportsType,
+ * 	CodeGenerationContext,
+ * 	CodeGenerationResultData,
+ * 	CodeGenerationResult,
+ * 	LibIdentOptions,
+ * 	LibIdent,
+ * 	NameForCondition,
+ * 	ReadOnlyRuntimeRequirements,
+ * 	RuntimeRequirements,
+ * 	SourceTypes
+ * } from "../Module"
+ */
+/** @import ModuleGraph from "../ModuleGraph" */
+/**
+ * @import ModuleGraphConnection, {
+ * 	ConnectionState
+ * } from "../ModuleGraphConnection"
+ */
+/** @import RequestShortener from "../RequestShortener" */
+/** @import { ResolverWithOptions } from "../ResolverFactory" */
+/** @import RuntimeTemplate from "../RuntimeTemplate" */
+/**
+ * @import {
+ * 	JavascriptModuleBuildInfo,
+ * 	JavascriptModuleBuildMeta
+ * } from "../javascript/JavascriptModule"
+ */
+/**
+ * @import {
+ * 	ChunkRenderContext,
+ * 	Scope,
+ * 	Reference,
+ * 	Variable
+ * } from "../javascript/JavascriptModulesPlugin"
+ */
+/** @import { Range } from "../javascript/JavascriptParser" */
+/** @import { Identifier, Program } from "estree" */
+/**
+ * @import {
+ * 	ObjectDeserializerContext
+ * } from "../serialization/ObjectMiddleware"
+ */
+/** @import Hash, { HashFunction } from "../util/Hash" */
+/** @import { UsedNames, UsedNamesInScopeInfo } from "../util/concatenate" */
+/** @import { InputFileSystem } from "../util/fs" */
+/** @import { AssociatedObjectForCache } from "../util/identifier" */
+/** @import { RuntimeSpec } from "../util/runtime" */
 /**
  * @template T
  * @typedef {import("../InitFragment")<T>} InitFragment
@@ -118,13 +142,33 @@ const { InlinedUsedName } = require("./InlineExports");
  * @typedef {import("../util/comparators").Comparator<T>} Comparator
  */
 
-// fix eslint-scope to support class properties correctly
-// cspell:word Referencer
-const ReferencerClass = Referencer;
-if (!ReferencerClass.prototype.PropertyDefinition) {
-	ReferencerClass.prototype.PropertyDefinition =
-		ReferencerClass.prototype.Property;
-}
+const IDENTIFIER_SCAN_REGEXP = /[$A-Za-z_][\w$]*/g;
+const IDENTIFIER_SCAN_WHITESPACE = new Set([" ", "\t", "\n", "\r"]);
+
+/**
+ * Finds every identifier a generated source could resolve against the enclosing
+ * concatenation scope. Property names are skipped; string and comment contents
+ * are not, which only over-reserves.
+ * @param {Source} source generated source
+ * @returns {ReadonlySet<string>} identifier names
+ */
+const findIdentifiers = (source) => {
+	const code = source.source().toString();
+	/** @type {Set<string>} */
+	const result = new Set();
+	IDENTIFIER_SCAN_REGEXP.lastIndex = 0;
+	let match = IDENTIFIER_SCAN_REGEXP.exec(code);
+	while (match !== null) {
+		let i = match.index - 1;
+		while (i >= 0 && IDENTIFIER_SCAN_WHITESPACE.has(code[i])) i--;
+		// `a.b` can't bind to the outer scope, but the `b` of `...b` can
+		if (!(i >= 0 && code[i] === "." && code[i - 1] !== ".")) {
+			result.add(match[0]);
+		}
+		match = IDENTIFIER_SCAN_REGEXP.exec(code);
+	}
+	return result;
+};
 
 /** @typedef {RawBinding | SymbolBinding} Binding */
 
@@ -156,20 +200,23 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
 /**
  * @typedef {object} ConcatenatedModuleInfo
  * @property {"concatenated"} type
+ * @property {boolean} wrapped the body renders inside the lazy CJS wrapper with real module/exports instead of being scope-hoisted into the shared scope
+ * @property {boolean} eager a wrapped body reached by an eager import edge, so its accessor is called at its own slot in evaluation order
  * @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
  * @property {InitFragment<ChunkRenderContext>[]=} chunkInitFragments
  * @property {ReadOnlyRuntimeRequirements | undefined} runtimeRequirements
  * @property {Scope | undefined} globalScope
+ * @property {Reference[] | undefined} unresolvedReferences the module's free references
  * @property {Scope | undefined} moduleScope
  * @property {Map<string, string>} internalNames
  * @property {ExportMap | undefined} exportMap
  * @property {ExportMap | undefined} rawExportMap
  * @property {string=} namespaceExportSymbol
+ * @property {string | undefined} namespaceFnName name of the lazy wrapper accessor function (calling it evaluates the module and returns its exports)
  * @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
@@ -186,11 +233,14 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
 /**
  * @typedef {object} ExternalModuleInfo
  * @property {"external"} type
+ * @property {boolean} wrapped the module's `require()` call is deferred behind an accessor instead of running at its own slot; unlike a wrapped concatenated member there is no body and no CJS wrapper, so any external may be wrapped
+ * @property {boolean} eager a wrapped module reached by an eager import edge, so its accessor is called at its own slot in evaluation order
  * @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} namespaceFnName lazy module accessor
  * @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
@@ -290,11 +340,36 @@ const subtractNonDeferAccess = (a, b) => a && !b;
 /**
  * @typedef {object} ConcatenationEntry
  * @property {"concatenated" | "external"} type
+ * @property {boolean} wrapped evaluation is deferred behind an accessor: a "concatenated" entry renders its body inside the lazy CJS wrapper instead of being scope-hoisted, an "external" entry only defers its `require()` call
  * @property {Module} module
  * @property {RuntimeSpec | boolean} runtimeCondition
  * @property {NonDeferAccess} nonDeferAccess
  */
 
+/**
+ * Whether a member runs inside the lazy CJS wrapper or is scope-hoisted. Only a
+ * NormalModule can carry a CJS body; an ESM member starts out hoisted and is
+ * downgraded by {@link ConcatenatedModule._createConcatenationList}.
+ * @param {Module} module a module taking part in the concatenation
+ * @returns {boolean} true, when the module renders wrapped
+ */
+const needWrapped = (module) =>
+	module instanceof NormalModule &&
+	module.type.startsWith("javascript/") &&
+	module.buildMeta !== undefined &&
+	module.buildMeta.exportsType !== "namespace";
+
+/**
+ * Whether a hoisted member can move into the lazy wrapper instead.
+ * @param {ConcatenationEntry} entry a member of the concatenation
+ * @returns {boolean} true, when it may be wrapped
+ */
+const entryCanBeWrapped = (entry) =>
+	(entry.module instanceof NormalModule &&
+		!entry.module.type.startsWith("css/")) ||
+	(entry.module instanceof ExternalModule &&
+		entry.module.canBeWrappedInConcatenation());
+
 /** @typedef {Set<ConcatenatedModuleInfo>} NeededNamespaceObjects */
 
 /** @typedef {Map<Module, ModuleInfo>} ModuleToInfoMap */
@@ -320,6 +395,40 @@ const getExportsType = (moduleGraph, info, strict) => {
 	return info.exportsTypeNonStrict;
 };
 
+/**
+ * @param {ExternalModuleInfo} info module info
+ * @returns {string} module exports expression
+ */
+const getExternalModuleExpr = (info) =>
+	info.wrapped
+		? `${
+				/** @type {NonNullable<ExternalModuleInfo["namespaceFnName"]>} */
+				(info.namespaceFnName)
+			}()`
+		: /** @type {NonNullable<ExternalModuleInfo["name"]>} */ (info.name);
+
+/**
+ * A wrapped module's interop object is declared as a lazy accessor, so reading
+ * it is a call. See `declareInterop`.
+ * @param {ModuleInfo} info module info
+ * @param {string | undefined} interopName interop variable name
+ * @returns {string} interop object expression
+ */
+const getInteropExpr = (info, interopName) =>
+	info.wrapped ? `${interopName}()` : /** @type {string} */ (interopName);
+
+/**
+ * Expression for an export that is not used. A hoisted body runs at its own
+ * slot, but a wrapped one only runs when its accessor is called, so dropping
+ * the reference would drop the module's side effects with it.
+ * @param {ConcatenatedModuleInfo} info module info
+ * @returns {string} expression evaluating to undefined
+ */
+const getUnusedExportExpr = (info) =>
+	info.wrapped
+		? `/* unused export */ (${info.namespaceObjectName}, undefined)`
+		: "/* unused export */ undefined";
+
 /**
  * @param {ModuleGraph} moduleGraph the module graph
  * @param {ModuleInfo} info module info
@@ -333,7 +442,8 @@ const getExportsType = (moduleGraph, info, strict) => {
  * @param {boolean} depDeferred the dependency is deferred
  * @param {boolean | undefined} strictHarmonyModule strictHarmonyModule
  * @param {boolean | undefined} asiSafe asiSafe
- * @param {Set<ExportInfo>=} alreadyVisited alreadyVisited
+ * @param {boolean=} moduleExportsAccess resolve to the module's own exports value with plain property access, skipping ESM interop
+ * @param {Set<InstanceType<ExportInfo>>=} alreadyVisited alreadyVisited
  * @returns {Binding} the final variable
  */
 const getFinalBinding = (
@@ -349,6 +459,7 @@ const getFinalBinding = (
 	depDeferred,
 	strictHarmonyModule,
 	asiSafe,
+	moduleExportsAccess,
 	alreadyVisited
 ) => {
 	const exportsType = getExportsType(moduleGraph, info, strictHarmonyModule);
@@ -357,35 +468,57 @@ const getFinalBinding = (
 		info.deferred &&
 		!(/** @type {BuildMeta} */ (info.module.buildMeta).async);
 	const deferred = depDeferred && moduleDeferred;
+
+	if (moduleExportsAccess && info.type === "concatenated") {
+		neededNamespaceObjects.add(info);
+		// ids arrive as declared names and the rendered exports object is keyed by
+		// used ones, so resolve here — the same way `case "external"` does below.
+		// Resolving in the caller instead would mangle twice.
+		const usedName =
+			exportName.length === 0
+				? exportName
+				: moduleGraph
+						.getExportsInfo(info.module)
+						.getUsedName(exportName, runtime);
+		if (!usedName) {
+			return {
+				info,
+				rawName: getUnusedExportExpr(info),
+				ids: [],
+				exportName
+			};
+		}
+		return {
+			info,
+			rawName:
+				/** @type {NonNullable<ConcatenatedModuleInfo["namespaceObjectName"]>} */
+				(info.namespaceObjectName),
+			ids: /** @type {ExportName} */ (usedName),
+			exportName
+		};
+	}
+
 	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 {
 					info,
-					rawName: /** @type {string} */ (
-						deferred
-							? info.deferredNamespaceObjectName
-							: info.interopNamespaceObject2Name
-					),
+					rawName: deferred
+						? /** @type {string} */ (info.deferredNamespaceObjectName)
+						: getInteropExpr(info, info.interopNamespaceObject2Name),
 					ids: exportName,
 					exportName
 				};
 			case "default-with-named":
-				if (info.type === "concatenated") neededNamespaceObjects.add(info);
 				if (deferred) info.deferredNamespaceObjectUsed = true;
 				else info.interopNamespaceObjectUsed = true;
 				return {
 					info,
-					rawName: /** @type {string} */ (
-						deferred
-							? info.deferredNamespaceObjectName
-							: info.interopNamespaceObjectName
-					),
+					rawName: deferred
+						? /** @type {string} */ (info.deferredNamespaceObjectName)
+						: getInteropExpr(info, info.interopNamespaceObjectName),
 					ids: exportName,
 					exportName
 				};
@@ -476,19 +609,23 @@ const getFinalBinding = (
 						if (moduleDeferred) {
 							return {
 								info,
-								rawName: /** @type {string} */ (info.name),
+								rawName: getExternalModuleExpr(info),
 								ids: exportName,
 								exportName
 							};
 						}
 						info.interopDefaultAccessUsed = true;
+						const accessor = getInteropExpr(
+							info,
+							info.interopDefaultAccessName
+						);
 						const defaultExport = asCall
-							? `${info.interopDefaultAccessName}()`
+							? `${accessor}()`
 							: asiSafe
-								? `(${info.interopDefaultAccessName}())`
+								? `(${accessor}())`
 								: asiSafe === false
-									? `;(${info.interopDefaultAccessName}())`
-									: `${info.interopDefaultAccessName}.a`;
+									? `;(${accessor}())`
+									: `${accessor}.a`;
 						return {
 							info,
 							rawName: defaultExport,
@@ -509,6 +646,7 @@ const getFinalBinding = (
 				throw new Error(`Unexpected exportsType ${exportsType}`);
 		}
 	}
+
 	if (exportName.length === 0) {
 		switch (info.type) {
 			case "concatenated":
@@ -533,9 +671,7 @@ const getFinalBinding = (
 				}
 				return {
 					info,
-					rawName:
-						/** @type {NonNullable<ExternalModuleInfo["name"]>} */
-						(info.name),
+					rawName: getExternalModuleExpr(info),
 					ids: exportName,
 					exportName
 				};
@@ -664,19 +800,41 @@ const getFinalBinding = (
 					/** @type {BuildMeta} */
 					(info.module.buildMeta).strictHarmonyModule,
 					asiSafe,
+					false,
 					alreadyVisited
 				);
 			}
 			// 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)
-				);
+			if (info.namespaceExportSymbol || info.wrapped) {
+				const usedName = exportsInfo.getUsedName(exportName, runtime);
+				if (!usedName) {
+					return {
+						info,
+						rawName: "/* unused export */ undefined",
+						ids: exportName.slice(1),
+						exportName
+					};
+				}
+				// an inlined export never reaches the exports object, so render the
+				// literal instead of reading the namespace
+				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
+					};
+				}
 				return {
 					info,
 					rawName: /** @type {string} */ (info.namespaceObjectName),
-					ids: usedName,
+					ids: /** @type {ExportName} */ (usedName),
 					exportName
 				};
 			}
@@ -717,8 +875,7 @@ const getFinalBinding = (
 			return {
 				info,
 				rawName:
-					(deferred ? info.deferredName : info.name) +
-					(deferred ? ".a" : "") +
+					(deferred ? `${info.deferredName}.a` : getExternalModuleExpr(info)) +
 					comment,
 				ids: usedName,
 				exportName
@@ -741,6 +898,7 @@ const getFinalBinding = (
  * @param {boolean | undefined} callContext callContext
  * @param {boolean | undefined} strictHarmonyModule strictHarmonyModule
  * @param {boolean | undefined} asiSafe asiSafe
+ * @param {boolean=} moduleExportsAccess resolve to the module's own exports value with plain property access, skipping ESM interop
  * @returns {string} the final name
  */
 const getFinalName = (
@@ -756,7 +914,8 @@ const getFinalName = (
 	depDeferred,
 	callContext,
 	strictHarmonyModule,
-	asiSafe
+	asiSafe,
+	moduleExportsAccess
 ) => {
 	const binding = getFinalBinding(
 		moduleGraph,
@@ -770,7 +929,8 @@ const getFinalName = (
 		asCall,
 		depDeferred,
 		strictHarmonyModule,
-		asiSafe
+		asiSafe,
+		moduleExportsAccess
 	);
 	{
 		const { ids, comment } = binding;
@@ -799,13 +959,19 @@ const getFinalName = (
 			reference = `${name}${comment || ""}${propertyAccess(ids)}`;
 			isPropertyAccess = ids.length > 1;
 		}
-		if (isPropertyAccess && asCall && callContext === false) {
-			return asiSafe
-				? `(0,${reference})`
-				: asiSafe === false
-					? `;(0,${reference})`
-					: `/*#__PURE__*/Object(${reference})`;
+
+		if (isPropertyAccess) {
+			if (asCall && callContext === false) {
+				return asiSafe
+					? `(0,${reference})`
+					: asiSafe === false
+						? `;(0,${reference})`
+						: `/*#__PURE__*/Object(${reference})`;
+			} else if (binding.info.wrapped) {
+				return asiSafe === false ? `;(${reference})` : `(${reference})`;
+			}
 		}
+
 		return reference;
 	}
 };
@@ -973,6 +1139,9 @@ class ConcatenatedModule extends Module {
 	 */
 	build(options, compilation, resolver, fs, callback) {
 		const { rootModule } = this;
+		const concatenateCommonJsModules = isCommonJsConcatenationEnabled(
+			options.optimization.concatenateModules
+		);
 		const { moduleArgument, exportsArgument } =
 			/** @type {BuildInfo} */
 			(rootModule.buildInfo);
@@ -1015,7 +1184,7 @@ class ConcatenatedModule extends Module {
 			// populate dependencies — keep only deps that leave the concat set
 			for (const d of m.dependencies) {
 				if (
-					!Dependency.canConcatenate(d) ||
+					!Dependency.canConcatenate(d, concatenateCommonJsModules) ||
 					!this._modules.has(
 						/** @type {Module} */
 						(compilation.moduleGraph.getModule(d))
@@ -1127,11 +1296,19 @@ class ConcatenatedModule extends Module {
 	 * @returns {ConcatenationEntry[]} concatenation list
 	 */
 	_createConcatenationList(rootModule, modulesSet, runtime, moduleGraph) {
+		const concatenateCommonJsModules = isCommonJsConcatenationEnabled(
+			this.compilation.options.optimization.concatenateModules
+		);
 		/** @type {ConcatenationEntry[]} */
 		const list = [];
 		/** @type {Map<Module, { runtimeCondition: RuntimeSpec | true, nonDeferAccess: NonDeferAccess }>} */
 		const existingEntries = new Map();
 
+		/** @type {Map<Module, Module[]>} */
+		const importConnections = new Map();
+		/** @type {Set<Module>} */
+		const wrappedModules = new Set();
+
 		/**
 		 * @param {Module} module a module
 		 * @returns {Iterable<{ connection: ModuleGraphConnection, runtimeCondition: RuntimeSpec | true, nonDeferAccess: NonDeferAccess }>} imported modules in order
@@ -1150,7 +1327,10 @@ class ConcatenatedModule extends Module {
 				.filter((connection) => {
 					if (
 						!connection.dependency ||
-						!Dependency.canConcatenate(connection.dependency)
+						!Dependency.canConcatenate(
+							connection.dependency,
+							concatenateCommonJsModules
+						)
 					) {
 						return false;
 					}
@@ -1172,7 +1352,12 @@ class ConcatenatedModule extends Module {
 						(connection.dependency);
 					return {
 						connection,
-						sourceOrder: /** @type {number} */ (dep.sourceOrder),
+						// A require() edge carries no sourceOrder; Infinity sorts it last,
+						// matching the low-priority sentinel. NaN must not be used here:
+						// compareNumbers returns 0 against every number, which makes the
+						// comparator non-transitive and the order depend on insertion order.
+						sourceOrder:
+							typeof dep.sourceOrder === "number" ? dep.sourceOrder : Infinity,
 						rangeStart: dep.range && dep.range[0],
 						defer: ImportPhaseUtils.isDefer(dep.phase)
 					};
@@ -1196,6 +1381,8 @@ class ConcatenatedModule extends Module {
 			references.sort(concatComparators(bySourceOrder, byRangeStart));
 			/** @type {Map<Module, { connection: ModuleGraphConnection, runtimeCondition: RuntimeSpec | true, nonDeferAccess: NonDeferAccess }>} */
 			const referencesMap = new Map();
+			/** @type {Module[] | undefined} */
+			let targets;
 			for (const { connection, defer } of references) {
 				const runtimeCondition = filterRuntime(runtime, (r) =>
 					connection.isTargetActive(r)
@@ -1203,6 +1390,17 @@ class ConcatenatedModule extends Module {
 				if (runtimeCondition === false) continue;
 				const nonDeferAccess = !defer;
 				const module = connection.module;
+				if (targets === undefined) targets = [module];
+				else if (!targets.includes(module)) targets.push(module);
+				if (
+					[
+						CommonJsRequireDependency,
+						CommonJsFullRequireDependency,
+						CommonJsExportRequireDependency
+					].some((Dep) => connection.dependency instanceof Dep)
+				) {
+					wrappedModules.add(module);
+				}
 				const entry = referencesMap.get(module);
 				if (entry === undefined) {
 					referencesMap.set(module, {
@@ -1222,6 +1420,7 @@ class ConcatenatedModule extends Module {
 					nonDeferAccess
 				);
 			}
+			if (targets !== undefined) importConnections.set(module, targets);
 			return referencesMap.values();
 		};
 
@@ -1269,6 +1468,7 @@ class ConcatenatedModule extends Module {
 				}
 				list.push({
 					type: "concatenated",
+					wrapped: needWrapped(module),
 					module: connection.module,
 					runtimeCondition,
 					nonDeferAccess
@@ -1335,6 +1535,7 @@ class ConcatenatedModule extends Module {
 				}
 				list.push({
 					type: "external",
+					wrapped: wrappedModules.has(connection.module),
 					get module() {
 						// We need to use a getter here, because the module in the dependency
 						// could be replaced by some other process (i. e. also replaced with a
@@ -1357,11 +1558,39 @@ class ConcatenatedModule extends Module {
 		}
 		list.push({
 			type: "concatenated",
+			wrapped: needWrapped(rootModule),
 			module: rootModule,
 			runtimeCondition: true,
 			nonDeferAccess: true
 		});
 
+		// A lazily evaluated member may only depend on lazily evaluated members,
+		// so wrapping propagates forward from every `require()` target along all
+		// import edges, ESM included.
+		/** @type {Set<Module>} */
+		const modules = new Set(wrappedModules);
+		for (const entry of list) {
+			if (entry.wrapped) modules.add(entry.module);
+		}
+		const queue = [...modules];
+		for (let i = 0; i < queue.length; i++) {
+			const targets = importConnections.get(queue[i]);
+			if (targets === undefined) continue;
+			for (const target of targets) {
+				if (modules.has(target)) continue;
+				modules.add(target);
+				queue.push(target);
+			}
+		}
+		for (const entry of list) {
+			if (
+				!entry.wrapped &&
+				modules.has(entry.module) &&
+				entryCanBeWrapped(entry)
+			) {
+				entry.wrapped = true;
+			}
+		}
 		return list;
 	}
 
@@ -1416,6 +1645,40 @@ class ConcatenatedModule extends Module {
 		}
 	}
 
+	/*
+	 * How the inner modules become one flat source. Stages [1]-[5] only mutate the
+	 * per-module info records (names, ReplaceSource patches); stages [6]-[9] append
+	 * to the single output ConcatSource, in exactly the order shown.
+	 *
+	 *  _getModulesWithInfo() — ordered concatenation list + one info per module
+	 *  |     (concatenated [+wrapped] | external | reference)
+	 *  v
+	 *  [1] ANALYSE — inner codeGeneration() per module, into a ConcatenationScope
+	 *  |     plain    -> ReplaceSource + ast + scope analysis
+	 *  |     wrapped  -> ReplaceSource only, body kept verbatim
+	 *  |     external -> nothing yet, rendered as a require() below
+	 *  [2] RESERVE — free globals of the analysed bodies enter allUsedNames, so
+	 *  |     renaming in [3] can't shadow them (a wrapped body is not analysed;
+	 *  |     the reserved `__webpack_` prefix protects it)
+	 *  [3] RENAME — module-scope variables renamed inside the ReplaceSource, then
+	 *  |     the generated names allocated: wrapper accessor, namespace object,
+	 *  |     interop helpers, external import variable
+	 *  [4] LINK — __WEBPACK_MODULE_REFERENCE__ tokens replaced by their final
+	 *  |     binding; through the ast for analysed bodies, textually for wrapped
+	 *  [5] COLLECT EXPORTS — root exports split into used / unused / inlined
+	 *  v
+	 *  ---- from here on everything is appended to the result ConcatSource ----
+	 *  |
+	 *  [6] EMIT EXPORTS — __esModule flag + exports getters, UNUSED/INLINED lists
+	 *  [7] BUILD NS — namespace object sources built as strings (not emitted yet)
+	 *  [8] DEFINE — everything that must exist before any body runs: namespace
+	 *  |     objects, wrapper accessors (wrapped modules and wrapped externals),
+	 *  |     deferred external loaders
+	 *  [9] EVALUATE — bodies in concatenation order: plain bodies inline, externals
+	 *  |     as require(); a wrapped body stays behind its accessor
+	 *  v
+	 *  [10] RESULT — CodeGenerationResult { sources, data, runtimeRequirements }
+	 */
 	/**
 	 * Generates code and runtime requirements for this module.
 	 * @param {CodeGenerationContext} context context for code generation
@@ -1439,12 +1702,39 @@ class ConcatenatedModule extends Module {
 		const runtime = intersectRuntime(generationRuntime, this._runtime);
 
 		const requestShortener = runtimeTemplate.requestShortener;
-		// Meta info for each module
+		// Meta info for each module, in evaluation order (repeats become references)
 		const [modulesWithInfo, moduleToInfoMap] = this._getModulesWithInfo(
 			moduleGraph,
 			runtime
 		);
 
+		// This module's body is the root's body, so a wrapped root still evaluates
+		// at its slot. No import edge inside the concatenation expresses that.
+		const rootModuleInfo = moduleToInfoMap.get(this.rootModule);
+		if (rootModuleInfo !== undefined) rootModuleInfo.eager = true;
+
+		// State shared by all stages below, in the order they are filled
+
+		// List of all used names to avoid conflicts
+		const allUsedNames = new Set(RESERVED_NAMES);
+
+		// Updated Top level declarations are created by renaming
+		/** @type {TopLevelDeclarations} */
+		const topLevelDeclarations = new Set();
+
+		// 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 {UsedNamesInScopeInfo} */
+		const usedNamesInScopeInfo = new Map();
+
+		// Set of already checked scopes
+		/** @type {Set<Scope>} */
+		const ignoredScopes = new Set();
+
 		// Set with modules that need a generated namespace object
 		/** @type {NeededNamespaceObjects} */
 		const neededNamespaceObjects = new Set();
@@ -1454,11 +1744,8 @@ class ConcatenatedModule extends Module {
 		/** @type {Set<ConcatenatedModuleInfo | ExternalModuleInfo>} */
 		const neededEscapeNamespaceObjects = new Set();
 
-		// List of all used names to avoid conflicts
-		const allUsedNames = new Set(RESERVED_NAMES);
-
-		// Generate source code and analyse scopes
-		// Prepare a ReplaceSource for the final source
+		// #region [1] ANALYSE: run each inner module's own codeGeneration; a
+		// non-wrapped body is parsed and scope-analysed so [3] can rename its locals
 		for (const info of moduleToInfoMap.values()) {
 			this._analyseModule(
 				moduleToInfoMap,
@@ -1474,23 +1761,7 @@ class ConcatenatedModule extends Module {
 				allUsedNames
 			);
 		}
-
-		// Updated Top level declarations are created by renaming
-		/** @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 {UsedNamesInScopeInfo} */
-		const usedNamesInScopeInfo = new Map();
-
-		// Set of already checked scopes
-		/** @type {Set<Scope>} */
-		const ignoredScopes = new Set();
+		// #endregion
 
 		/**
 		 * Lazily allocates a decoupled namespace object for a concatenated module
@@ -1501,12 +1772,22 @@ class ConcatenatedModule extends Module {
 		 * @returns {string | undefined} the escape namespace object name
 		 */
 		const getEscapeNamespaceObjectName = (info) => {
-			if (info.type === "concatenated" && info.namespaceExportSymbol) {
+			// Only a hoisted member's namespaceExportSymbol is a real variable
+			// holding the original names; a wrapped one reuses the field for its
+			// `X_namespaceFn()` call, which exposes the mangled keys
+			if (
+				info.type === "concatenated" &&
+				!info.wrapped &&
+				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;
+			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);
@@ -1539,118 +1820,129 @@ class ConcatenatedModule extends Module {
 			return name;
 		};
 
-		// get all global names
+		// #region [2] RESERVE: the free globals of every analysed body. Claiming
+		// them up front is what lets [3] rename without shadowing any of them
 		for (const info of modulesWithInfo) {
-			if (info.type === "concatenated" && !info.cjsWrapped) {
-				// ignore symbols from moduleScope
-				if (info.moduleScope) {
-					ignoredScopes.add(info.moduleScope);
-				}
-
-				// The super class expression in class scopes behaves weird
-				// We get ranges of all super class expressions to make
-				// renaming to work correctly
-				/** @typedef {{ range: Range, variables: Variable[] }} ClassInfo */
-				/** @type {WeakMap<Scope, ClassInfo[]>} */
-				const superClassCache = new WeakMap();
-				/**
-				 * @param {Scope} scope scope
-				 * @returns {ClassInfo[]} result
-				 */
-				const getSuperClassExpressions = (scope) => {
-					const cacheEntry = superClassCache.get(scope);
-					if (cacheEntry !== undefined) return cacheEntry;
-					/** @type {ClassInfo[]} */
-					const superClassExpressions = [];
-					for (const childScope of scope.childScopes) {
-						if (childScope.type !== "class") continue;
-						const block = childScope.block;
+			if (info.type === "concatenated") {
+				if (info.wrapped) {
+					// The body is emitted verbatim and never renamed, so every identifier
+					// in it is claimed: its declarations must not shadow a name [3]
+					// generates, and its free globals must not be captured by one.
+					for (const name of findIdentifiers(
+						/** @type {Source} */ (info.internalSource)
+					)) {
+						allUsedNames.add(name);
+					}
+					// A wrapped body has no scope analysis, so its references are found
+					// textually. They still have to be resolved here: binding one is what
+					// flags the interop objects it needs, and [3] allocates their names.
+					/** @type {Set<string>} */
+					const visitedReferences = new Set();
+					for (const reference of ConcatenationScope.findModuleReferences(
+						/** @type {Source} */ (info.internalSource)
+					)) {
+						if (visitedReferences.has(reference.name)) continue;
+						visitedReferences.add(reference.name);
+						const match = ConcatenationScope.matchModuleReference(
+							reference.name
+						);
+						if (!match) continue;
+						const referencedInfo = modulesWithInfo[match.index];
+						if (referencedInfo.type === "reference") {
+							throw new Error("Module reference can't point to a reference");
+						}
 						if (
-							(block.type === "ClassDeclaration" ||
-								block.type === "ClassExpression") &&
-							block.superClass
+							match.mangleableNamespace &&
+							match.ids.length === 0 &&
+							getEscapeNamespaceObjectName(referencedInfo) !== undefined
 						) {
-							superClassExpressions.push({
-								range: /** @type {Range} */ (block.superClass.range),
-								variables: childScope.variables
-							});
+							continue;
 						}
+						getFinalBinding(
+							moduleGraph,
+							referencedInfo,
+							match.ids,
+							moduleToInfoMap,
+							runtime,
+							requestShortener,
+							runtimeTemplate,
+							neededNamespaceObjects,
+							match.call,
+							match.deferredImport,
+							/** @type {BuildMeta} */
+							(info.module.buildMeta).strictHarmonyModule,
+							match.asiSafe,
+							match.moduleExportsAccess
+						);
+					}
+				} else {
+					// ignore symbols from moduleScope
+					if (info.moduleScope) {
+						ignoredScopes.add(info.moduleScope);
 					}
-					superClassCache.set(scope, superClassExpressions);
-					return superClassExpressions;
-				};
 
-				// add global symbols
-				if (info.globalScope) {
-					for (const reference of info.globalScope.through) {
-						const name = reference.identifier.name;
-						if (ConcatenationScope.isModuleReference(name)) {
-							const match = ConcatenationScope.matchModuleReference(name);
-							if (!match) continue;
-							const referencedInfo = modulesWithInfo[match.index];
-							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,
-								match.ids,
-								moduleToInfoMap,
-								runtime,
-								requestShortener,
-								runtimeTemplate,
-								neededNamespaceObjects,
-								false,
-								match.deferredImport,
-								/** @type {BuildMeta} */
-								(info.module.buildMeta).strictHarmonyModule,
-								true
-							);
-							if (!binding.ids) continue;
-							const { usedNames, alreadyCheckedScopes } =
-								getUsedNamesInScopeInfo(
-									usedNamesInScopeInfo,
-									binding.info.module.identifier(),
-									"name" in binding ? binding.name : ""
-								);
-							for (const expr of getSuperClassExpressions(reference.from)) {
+					// add global symbols
+					if (info.unresolvedReferences) {
+						for (const reference of info.unresolvedReferences) {
+							const name = reference.identifier.name;
+							if (ConcatenationScope.isModuleReference(name)) {
+								const match = ConcatenationScope.matchModuleReference(name);
+								if (!match) continue;
+								const referencedInfo = modulesWithInfo[match.index];
+								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 (
-									expr.range[0] <=
-										/** @type {Range} */ (reference.identifier.range)[0] &&
-									expr.range[1] >=
-										/** @type {Range} */ (reference.identifier.range)[1]
+									match.mangleableNamespace &&
+									match.ids.length === 0 &&
+									getEscapeNamespaceObjectName(referencedInfo) !== undefined
 								) {
-									for (const variable of expr.variables) {
-										usedNames.add(variable.name);
-									}
+									continue;
 								}
+								const binding = getFinalBinding(
+									moduleGraph,
+									referencedInfo,
+									match.ids,
+									moduleToInfoMap,
+									runtime,
+									requestShortener,
+									runtimeTemplate,
+									neededNamespaceObjects,
+									false,
+									match.deferredImport,
+									/** @type {BuildMeta} */
+									(info.module.buildMeta).strictHarmonyModule,
+									true,
+									match.moduleExportsAccess
+								);
+								if (!binding.ids) continue;
+								const { usedNames, alreadyCheckedScopes } =
+									getUsedNamesInScopeInfo(
+										usedNamesInScopeInfo,
+										binding.info.module.identifier(),
+										"name" in binding ? binding.name : ""
+									);
+								addScopeSymbols(
+									reference.from,
+									usedNames,
+									alreadyCheckedScopes,
+									ignoredScopes
+								);
+							} else {
+								allUsedNames.add(name);
+								freeNames.add(name);
 							}
-							addScopeSymbols(
-								reference.from,
-								usedNames,
-								alreadyCheckedScopes,
-								ignoredScopes
-							);
-						} else {
-							allUsedNames.add(name);
-							freeNames.add(name);
 						}
 					}
 				}
 			}
 		}
+		// #endregion
 
 		/**
 		 * @param {string} name the name to find a new name for
@@ -1722,7 +2014,9 @@ class ConcatenatedModule extends Module {
 			}
 		};
 
-		// generate names for symbols
+		// #region [3] RENAME: rename every module-scope variable inside its
+		// ReplaceSource, then allocate the generated names (wrapper accessor,
+		// namespace object, interop helpers, external import variable)
 		for (const info of moduleToInfoMap.values()) {
 			const { usedNames: namespaceObjectUsedNames } = getUsedNamesInScopeInfo(
 				usedNamesInScopeInfo,
@@ -1731,82 +2025,85 @@ 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",
+					if (info.wrapped) {
+						// A wrapped module declares exactly one shared-scope name: the
+						// lazy wrapper accessor holding its body. [2] claimed every
+						// identifier of that body, so findNewName avoids the ones that
+						// would shadow the accessor from inside it.
+						const namespaceFnName = findNewName(
+							"namespaceFn",
 							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;
-						const references = getAllReferences(variable);
-						const newName = _findNewName(name, info, references);
-						if (newName) {
-							const source = /** @type {ReplaceSource} */ (info.source);
-							/** @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(
-									/** @type {NonNullable<ConcatenatedModuleInfo["ast"]>} */
-									(info.ast),
-									identifier
-								);
-								if (path && path.length > 1) {
-									const maybeProperty =
-										path[1].type === "AssignmentPattern" &&
-										path[1].left === path[0]
-											? path[2]
-											: path[1];
-									if (
-										maybeProperty.type === "Property" &&
-										maybeProperty.shorthand
-									) {
-										source.insert(r[1], `: ${newName}`);
-										continue;
+						allUsedNames.add(namespaceFnName);
+						topLevelDeclarations.add(namespaceFnName);
+						info.namespaceFnName = namespaceFnName;
+						// Every reference — `require()` and ESM import alike — reads the
+						// live exports object through the accessor, so the namespace is
+						// the call itself, not a variable. Not a declared name.
+						info.namespaceObjectName = `${namespaceFnName}()`;
+					} else {
+						const variables = /** @type {Scope} */ (info.moduleScope).variables;
+						for (const variable of variables) {
+							const name = variable.name;
+							const references = getAllReferences(variable);
+							const newName = _findNewName(name, info, references);
+							if (newName) {
+								const source = /** @type {ReplaceSource} */ (info.source);
+								/** @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(
+										/** @type {NonNullable<ConcatenatedModuleInfo["ast"]>} */
+										(info.ast),
+										identifier
+									);
+									if (path && path.length > 1) {
+										const maybeProperty =
+											path[1].type === "AssignmentPattern" &&
+											path[1].left === path[0]
+												? path[2]
+												: path[1];
+										if (
+											maybeProperty.type === "Property" &&
+											maybeProperty.shorthand
+										) {
+											source.insert(r[1], `: ${newName}`);
+											continue;
+										}
 									}
+									source.replace(r[0], r[1] - 1, newName);
 								}
-								source.replace(r[0], r[1] - 1, newName);
+							} else {
+								allUsedNames.add(name);
+								info.internalNames.set(name, name);
+								topLevelDeclarations.add(name);
 							}
+						}
+						/** @type {string} */
+						let namespaceObjectName;
+						if (info.namespaceExportSymbol) {
+							namespaceObjectName =
+								/** @type {string} */
+								(info.internalNames.get(info.namespaceExportSymbol));
 						} else {
-							allUsedNames.add(name);
-							info.internalNames.set(name, name);
-							topLevelDeclarations.add(name);
+							namespaceObjectName = findNewName(
+								"namespaceObject",
+								allUsedNames,
+								namespaceObjectUsedNames,
+								info.module.readableIdentifier(requestShortener)
+							);
+							allUsedNames.add(namespaceObjectName);
 						}
+						info.namespaceObjectName = namespaceObjectName;
+						topLevelDeclarations.add(namespaceObjectName);
 					}
-					/** @type {string} */
-					let namespaceObjectName;
-					if (info.namespaceExportSymbol) {
-						namespaceObjectName =
-							/** @type {string} */
-							(info.internalNames.get(info.namespaceExportSymbol));
-					} else {
-						namespaceObjectName = findNewName(
-							"namespaceObject",
-							allUsedNames,
-							namespaceObjectUsedNames,
-							info.module.readableIdentifier(requestShortener)
-						);
-						allUsedNames.add(namespaceObjectName);
-					}
-					info.namespaceObjectName = namespaceObjectName;
-					topLevelDeclarations.add(namespaceObjectName);
 					break;
 				}
 				case "external": {
@@ -1820,6 +2117,18 @@ class ConcatenatedModule extends Module {
 					info.name = externalName;
 					topLevelDeclarations.add(externalName);
 
+					if (info.wrapped) {
+						const namespaceFnName = findNewName(
+							"namespaceFn",
+							allUsedNames,
+							namespaceObjectUsedNames,
+							info.module.readableIdentifier(requestShortener)
+						);
+						allUsedNames.add(namespaceFnName);
+						info.namespaceFnName = namespaceFnName;
+						topLevelDeclarations.add(namespaceFnName);
+					}
+
 					if (info.deferred) {
 						const externalName = findNewName(
 							"deferred",
@@ -1883,15 +2192,20 @@ class ConcatenatedModule extends Module {
 				topLevelDeclarations.add(externalNameInterop);
 			}
 		}
+		// #endregion
 
-		// Find and replace references to modules
+		// #region [4] LINK: resolve each cross-module reference token to the final
+		// name picked in [3] and patch it in. Must run after [3] — a reference can
+		// only be resolved once its target has been named
 		for (const info of moduleToInfoMap.values()) {
-			if (info.type === "concatenated" && !info.cjsWrapped) {
-				const globalScope = /** @type {Scope} */ (info.globalScope);
+			if (info.type !== "concatenated") continue;
+			if (!info.wrapped) {
 				// group references by name
 				/** @type {Map<string, Reference[]>} */
 				const referencesByName = new Map();
-				for (const reference of globalScope.through) {
+				for (const reference of /** @type {Reference[]} */ (
+					info.unresolvedReferences
+				)) {
 					const name = reference.identifier.name;
 					let references = referencesByName.get(name);
 					if (references === undefined) {
@@ -1936,10 +2250,7 @@ class ConcatenatedModule extends Module {
 						// 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")
+							match.mangleableNamespace && match.ids.length === 0
 								? getEscapeNamespaceObjectName(referencedInfo)
 								: undefined;
 						const finalName =
@@ -1959,7 +2270,8 @@ class ConcatenatedModule extends Module {
 										!match.directImport,
 										/** @type {BuildMeta} */
 										(info.module.buildMeta).strictHarmonyModule,
-										match.asiSafe
+										match.asiSafe,
+										match.moduleExportsAccess
 									);
 
 						for (const reference of references) {
@@ -1970,9 +2282,64 @@ class ConcatenatedModule extends Module {
 						}
 					}
 				}
+			} else {
+				// Wrapped bodies are not re-parsed: find their reference tokens
+				// textually. [2] scanned the same source, so this reuses its result.
+				/** @type {Map<string, string>} */
+				const finalNames = new Map();
+				const source = /** @type {ReplaceSource} */ (info.source);
+				for (const reference of ConcatenationScope.findModuleReferences(
+					/** @type {Source} */ (info.internalSource)
+				)) {
+					let finalName = finalNames.get(reference.name);
+					if (finalName === undefined) {
+						const match = ConcatenationScope.matchModuleReference(
+							reference.name
+						);
+						if (!match) continue;
+						const referencedInfo = modulesWithInfo[match.index];
+						if (referencedInfo.type === "reference") {
+							throw new Error("Module reference can't point to a reference");
+						}
+						// Same escaping whole-namespace rule as the hoisted branch above: a
+						// wrapped target resolves to its `X_namespaceFn()` exports object,
+						// whose keys are the mangled ones.
+						const escapeName =
+							match.mangleableNamespace && match.ids.length === 0
+								? getEscapeNamespaceObjectName(referencedInfo)
+								: undefined;
+						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,
+										match.moduleExportsAccess
+									);
+						finalNames.set(reference.name, finalName);
+					}
+					// token end is extended by 2 chars to cover the appended "._"
+					source.replace(reference.start, reference.end + 1, finalName);
+				}
 			}
 		}
+		// #endregion
 
+		// #region [5] COLLECT EXPORTS: split the root module's exports into used /
+		// unused / inlined. Used ones stay thunks — resolving one can still
+		// register a namespace object, which [7] must see
 		// Map with all root exposed used exports
 		/** @type {Map<string, (requestShortener: RequestShortener) => string>} */
 		const exportsMap = new Map();
@@ -2034,7 +2401,10 @@ class ConcatenatedModule extends Module {
 				}
 			});
 		}
+		// #endregion
 
+		// #region [6] EMIT EXPORTS: first thing in the output — the exports getters
+		// must exist before any body runs, so circular importers see them
 		const result = new ConcatSource();
 
 		// add harmony compatibility flag (must be first because of possible circular dependencies)
@@ -2063,15 +2433,14 @@ class ConcatenatedModule extends Module {
 			runtimeRequirements.add(RuntimeGlobals.exports);
 			runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
 
-			if (shouldAddHarmonyFlag) {
-				result.add("// ESM COMPAT FLAG\n");
-				result.add(
-					runtimeTemplate.defineEsModuleFlagStatement({
+			// Goes with the definitions below: whoever takes those over emits both,
+			// and the marker has to stay in front of them.
+			const harmonyFlagSource = shouldAddHarmonyFlag
+				? `// ESM COMPAT FLAG\n${runtimeTemplate.defineEsModuleFlagStatement({
 						exportsArgument: this.exportsArgument,
 						runtimeRequirements
-					})
-				);
-			}
+					})}`
+				: "";
 
 			const exportsSource =
 				"\n// EXPORTS\n" +
@@ -2086,10 +2455,11 @@ class ConcatenatedModule extends Module {
 				!onDemandExportsGeneration.call(
 					this,
 					runtimes,
-					exportsSource,
+					`${harmonyFlagSource}${exportsSource}`,
 					exportsFinalName
 				)
 			) {
+				result.add(harmonyFlagSource);
 				result.add(exportsSource);
 			}
 		}
@@ -2107,7 +2477,12 @@ class ConcatenatedModule extends Module {
 				`\n// INLINED EXPORTS: ${joinIterableWithComma(inlinedExports)}\n`
 			);
 		}
+		// #endregion
 
+		// #region [7] BUILD NS: namespace object sources are built as strings here
+		// and emitted by [8]; an external's is emitted next to its import variable
+		// or accessor instead, which is defined later.
+		//
 		// 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
@@ -2139,9 +2514,7 @@ class ConcatenatedModule extends Module {
 					// import variable; concatenated ones resolve to an internal binding.
 					const finalName =
 						info.type === "external"
-							? `${/** @type {string} */ (info.name)}${propertyAccess([
-									usedName
-								])}`
+							? `${getExternalModuleExpr(info)}${propertyAccess([usedName])}`
 							: getFinalName(
 									moduleGraph,
 									info,
@@ -2192,50 +2565,41 @@ ${defineGetters}`
 		/** @type {Map<ConcatenatedModuleInfo, string>} */
 		const namespaceObjectSources = new Map();
 		for (const info of neededNamespaceObjects) {
-			if (info.namespaceExportSymbol) continue;
+			if (
+				info.namespaceExportSymbol ||
+				// Skip constructing namespace object generated for wrapped module
+				info.wrapped
+			) {
+				continue;
+			}
 			/** @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) {
-					// 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)}`
-						);
-					}
+				if (usedName && !(usedName instanceof InlinedUsedName)) {
+					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;
@@ -2258,20 +2622,92 @@ ${defineGetters}`
 			);
 			runtimeRequirements.add(RuntimeGlobals.makeNamespaceObject);
 		}
+		// #endregion
+
+		// #region [8] DEFINE: define required namespace objects and wrapper
+		// (must be before evaluation modules — a cycle member calls another's
+		// accessor before that module's own position in the order)
 
-		// define required namespace objects (must be before evaluation modules)
+		// wrapper accessors are only called later, so their definitions may be
+		// emitted in a stable order of their own instead of concatenation order
+		/** @type {(ConcatenatedModuleInfo | ExternalModuleInfo)[]} */
+		const wrappedInfos = [];
 		for (const info of modulesWithInfo) {
+			if (
+				(info.type === "concatenated" || info.type === "external") &&
+				info.wrapped
+			) {
+				wrappedInfos.push(info);
+			}
+		}
+		const compareWrappedModules = compareModulesByFullName(
+			runtimeTemplate.compilation.compiler
+		);
+		wrappedInfos.sort((a, b) => compareWrappedModules(a.module, b.module));
+
+		for (const info of wrappedInfos) {
 			if (info.type === "concatenated") {
-				const source = namespaceObjectSources.get(info);
-				if (source) result.add(source);
-				const escapeSource = escapeNamespaceObjectSources.get(
-					/** @type {ConcatenatedModuleInfo} */ (info)
+				runtimeRequirements.add(RuntimeGlobals.concatenationWrap);
+				result.add(
+					`\n// MODULE: ${info.module.readableIdentifier(
+						requestShortener
+					)}\nvar ${info.namespaceFnName} = /*#__PURE__*/${
+						RuntimeGlobals.concatenationWrap
+					}(function(${info.module.moduleArgument}, ${
+						info.module.exportsArgument
+					}) {\n`
+				);
+				result.add(/** @type {ReplaceSource} */ (info.source));
+				// A generated body (json, asset, html) binds its value to a local
+				// instead of writing exports; hand that local to the accessor. The
+				// name is verbatim: a wrapped body is not scope-analysed, so it keeps
+				// the reserved symbol the generator registered.
+				result.add(
+					info.namespaceExportSymbol
+						? `\n${info.module.moduleArgument}.exports = ${info.namespaceExportSymbol};\n});\n`
+						: "\n});\n"
+				);
+				// its getters call the accessor lazily, so this may sit right after it
+				const escapeSource = escapeNamespaceObjectSources.get(info);
+				if (escapeSource) result.add(escapeSource);
+			} else if (info.type === "external") {
+				runtimeRequirements.add(RuntimeGlobals.require);
+				const { runtimeCondition } = info;
+				const condition = runtimeTemplate.runtimeConditionExpression({
+					chunkGraph,
+					runtimeCondition,
+					runtime,
+					runtimeRequirements
+				});
+				const moduleId = JSON.stringify(chunkGraph.getModuleId(info.module));
+				const body =
+					condition === "true"
+						? `return ${RuntimeGlobals.require}(${moduleId});`
+						: `if (${condition}) return ${RuntimeGlobals.require}(${moduleId});`;
+				result.add(
+					`\n// EXTERNAL MODULE: ${info.module.readableIdentifier(
+						requestShortener
+					)}\nvar ${info.namespaceFnName} = ${runtimeTemplate.basicFunction(
+						"",
+						body
+					)};\n`
 				);
+				const escapeSource = escapeNamespaceObjectSources.get(info);
 				if (escapeSource) result.add(escapeSource);
-				if (!source && !escapeSource) continue;
 			}
+		}
 
-			if (info.type === "external" && info.deferred) {
+		for (const info of modulesWithInfo) {
+			if (info.type === "concatenated") {
+				if (!info.wrapped) {
+					const source = namespaceObjectSources.get(info);
+					if (source) result.add(source);
+					const escapeSource = escapeNamespaceObjectSources.get(
+						/** @type {ConcatenatedModuleInfo} */ (info)
+					);
+					if (escapeSource) result.add(escapeSource);
+				}
+			} else if (info.type === "external" && info.deferred) {
 				const moduleId = JSON.stringify(chunkGraph.getModuleId(info.module));
 				const loader = getOptimizedDeferredModule(
 					moduleId,
@@ -2316,10 +2752,13 @@ ${defineGetters}`
 			}
 		}
 
+		// #endregion
+
+		// #region [9] EVALUATE: emit the bodies in concatenation order and collect
+		// what they need — runtime requirements, chunk init fragments, interop
 		/** @type {InitFragment<ChunkRenderContext>[]} */
 		const chunkInitFragments = [];
 
-		// evaluate modules in order
 		for (const rawInfo of modulesWithInfo) {
 			/** @type {undefined | string} */
 			let name;
@@ -2327,35 +2766,47 @@ ${defineGetters}`
 			const info = rawInfo.type === "reference" ? rawInfo.target : rawInfo;
 			switch (info.type) {
 				case "concatenated": {
-					result.add(
-						`\n;// ${info.module.readableIdentifier(requestShortener)}\n`
-					);
-					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);
+					name = info.namespaceObjectName;
+					// wrapped bodies are emitted above, evaluated at their call sites
+					if (info.wrapped && info.eager) {
+						// This slot is the module's place in evaluation order; calling from
+						// the importing body would run it too late.
 						result.add(
-							`var ${info.namespaceObjectName} = /*#__PURE__*/${RuntimeGlobals.commonJsWrap}(function(${info.module.moduleArgument}, ${info.module.exportsArgument}) {\n`
+							`\n;// ${info.module.readableIdentifier(
+								requestShortener
+							)}\n${info.namespaceFnName}();\n`
+						);
+					} else if (!info.wrapped) {
+						result.add(
+							`\n;// ${info.module.readableIdentifier(requestShortener)}\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);
 					}
 					if (info.runtimeRequirements) {
 						for (const r of info.runtimeRequirements) {
+							// Wrapped module supplies module/exports/this itself
+							if (
+								info.wrapped &&
+								(r === RuntimeGlobals.module ||
+									r === RuntimeGlobals.exports ||
+									r === RuntimeGlobals.thisAsExports)
+							) {
+								continue;
+							}
 							runtimeRequirements.add(r);
 						}
 					}
-					name = info.namespaceObjectName;
+
 					break;
 				}
 				case "external": {
-					// deferred case is handled in the "const info of modulesWithInfo" loop above
-					if (!info.deferred) {
+					name = getExternalModuleExpr(info);
+					// deferred and wrapped cases are handled in the "const info of modulesWithInfo" loop above
+					if (!info.deferred && !info.wrapped) {
 						result.add(
 							`\n// EXTERNAL MODULE: ${info.module.readableIdentifier(
 								requestShortener
@@ -2382,11 +2833,17 @@ ${defineGetters}`
 						// 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);
+					} else if (info.wrapped && info.eager) {
+						result.add(
+							`\n;// EXTERNAL MODULE: ${info.module.readableIdentifier(
+								requestShortener
+							)}\n${info.namespaceFnName}();\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"),
@@ -2394,7 +2851,7 @@ ${defineGetters}`
 					const { nonDeferAccess } =
 						/** @type {ExternalModuleInfo | ReferenceToModuleInfo} */
 						(rawInfo);
-					if (info.deferred && nonDeferAccess) {
+					if (info.deferred && nonDeferAccess && !info.wrapped) {
 						result.add(
 							`\n// non-deferred import to a deferred module (${info.module.readableIdentifier(
 								requestShortener
@@ -2407,29 +2864,54 @@ ${defineGetters}`
 					// @ts-expect-error never is expected here
 					throw new Error(`Unsupported concatenation entry type ${info.type}`);
 			}
+			// Building a wrapped module's interop object here would evaluate its body
+			// at the top level and break require() cycles, so defer it behind a
+			// hoisted function. The memo lives on the function object: it keeps the
+			// identity stable without claiming a second top-level name.
+			/**
+			 * @param {string} interopName interop variable name
+			 * @param {string} expr interop object expression
+			 * @returns {string} the declaration
+			 */
+			const declareInterop = (interopName, expr) =>
+				info.wrapped
+					? `\nfunction ${interopName}() { return ${interopName}.c || (${interopName}.c = ${expr}); }`
+					: `\nvar ${interopName} = /*#__PURE__*/${expr};`;
 			if (info.interopNamespaceObjectUsed) {
 				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
 				result.add(
-					`\nvar ${info.interopNamespaceObjectName} = /*#__PURE__*/${RuntimeGlobals.createFakeNamespaceObject}(${name}, 2);`
+					declareInterop(
+						/** @type {string} */ (info.interopNamespaceObjectName),
+						`${RuntimeGlobals.createFakeNamespaceObject}(${name}, 2)`
+					)
 				);
 			}
 			if (info.interopNamespaceObject2Used) {
 				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
 				result.add(
-					`\nvar ${info.interopNamespaceObject2Name} = /*#__PURE__*/${RuntimeGlobals.createFakeNamespaceObject}(${name});`
+					declareInterop(
+						/** @type {string} */ (info.interopNamespaceObject2Name),
+						`${RuntimeGlobals.createFakeNamespaceObject}(${name})`
+					)
 				);
 			}
 			if (info.interopDefaultAccessUsed) {
 				runtimeRequirements.add(RuntimeGlobals.compatGetDefaultExport);
 				result.add(
-					`\nvar ${info.interopDefaultAccessName} = /*#__PURE__*/${RuntimeGlobals.compatGetDefaultExport}(${name});`
+					declareInterop(
+						/** @type {string} */ (info.interopDefaultAccessName),
+						`${RuntimeGlobals.compatGetDefaultExport}(${name})`
+					)
 				);
 			}
 			if (isConditional) {
 				result.add("\n}");
 			}
 		}
+		// #endregion
 
+		// #region [10] RESULT: topLevelDeclarations and freeNames let consumers
+		// (mangling, an outer concatenation) reason about this source unparsed
 		/** @type {CodeGenerationResultData} */
 		const data = new Map();
 		if (chunkInitFragments.length > 0) {
@@ -2444,6 +2926,7 @@ ${defineGetters}`
 			data,
 			runtimeRequirements
 		};
+		// #endregion
 
 		return resultEntry;
 	}
@@ -2474,43 +2957,17 @@ ${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
+			if (info.wrapped) {
+				// the wrapper isolates the body's top-level declarations, so no
+				// renaming is needed -- only a concatenation scope, to rewrite in-scope
+				// `require()` targets to accessor references. [2] claims its identifiers
+				// textually in place of the scope analysis skipped here.
 				const concatenationScope = new ConcatenationScope(
 					modulesMap,
 					info,
 					usedNames
 				);
-
-				// Not cached: Compilation memoizes the outer codeGeneration per
-				// (module, runtime), so inner generation never recomputes usefully.
+				info.concatenationScope = concatenationScope;
 				const codeGenResult = m.codeGeneration({
 					dependencyTemplates,
 					runtimeTemplate,
@@ -2526,69 +2983,95 @@ ${defineGetters}`
 					/** @type {Source} */
 					(codeGenResult.sources.get(JAVASCRIPT_TYPE));
 				const data = codeGenResult.data;
-				const chunkInitFragments = data && data.get("chunkInitFragments");
-				const code = source.source().toString();
-
-				/** @type {Program} */
-				let ast;
-
-				try {
-					const { experiments } = this.compilation.options;
-
-					({ ast } = JavascriptParser._parse(
-						code,
-						{
-							sourceType: "module",
-							ranges: true,
-							// generated code contains phase imports when the experiments are on
-							importPhases: Boolean(
-								experiments.deferImport || experiments.sourceImport
-							)
-						},
-						JavascriptParser._getModuleParseFunction(this.compilation, m)
-					));
-				} catch (_err) {
-					const err =
-						/** @type {Error & { loc?: { line: number, column: number } }} */
-						(_err);
-					if (
-						err.loc &&
-						typeof err.loc === "object" &&
-						typeof err.loc.line === "number"
-					) {
-						const lineNumber = err.loc.line;
-						const lines = code.split("\n");
-						err.message += `\n| ${lines
-							.slice(Math.max(0, lineNumber - 3), lineNumber + 2)
-							.join("\n| ")}`;
-					}
-					throw err;
-				}
-				const scopeManager = eslintScope.analyze(ast, {
-					ecmaVersion: 6,
-					sourceType: "module",
-					optimistic: true,
-					ignoreEval: true,
-					impliedStrict: true
-				});
-				const globalScope = /** @type {Scope} */ (scopeManager.acquire(ast));
-				const moduleScope = globalScope.childScopes[0];
-				const resultSource = new ReplaceSource(source);
 				info.runtimeRequirements =
 					/** @type {ReadOnlyRuntimeRequirements} */
 					(codeGenResult.runtimeRequirements);
-				info.ast = ast;
 				info.internalSource = source;
-				info.source = resultSource;
-				info.chunkInitFragments = chunkInitFragments;
-				info.globalScope = globalScope;
-				info.moduleScope = moduleScope;
-				info.concatenationScope = concatenationScope;
-			} catch (err) {
-				/** @type {Error} */
-				(err).message +=
-					`\nwhile analyzing module ${m.identifier()} for concatenation`;
-				throw err;
+				info.source = new ReplaceSource(source);
+				info.chunkInitFragments = data && data.get("chunkInitFragments");
+			} else {
+				try {
+					// Create a concatenation scope to track and capture information
+					const concatenationScope = new ConcatenationScope(
+						modulesMap,
+						info,
+						usedNames
+					);
+
+					// Not cached: Compilation memoizes the outer codeGeneration per
+					// (module, runtime), so inner generation never recomputes usefully.
+					const codeGenResult = m.codeGeneration({
+						dependencyTemplates,
+						runtimeTemplate,
+						moduleGraph,
+						chunkGraph,
+						runtime,
+						runtimes,
+						concatenationScope,
+						codeGenerationResults,
+						sourceTypes: JAVASCRIPT_TYPES
+					});
+					const source =
+						/** @type {Source} */
+						(codeGenResult.sources.get(JAVASCRIPT_TYPE));
+					const data = codeGenResult.data;
+					const chunkInitFragments = data && data.get("chunkInitFragments");
+					const code = source.source().toString();
+
+					/** @type {Program} */
+					let ast;
+
+					try {
+						const { experiments } = this.compilation.options;
+
+						({ ast } = JavascriptParser._parse(
+							code,
+							{
+								sourceType: "module",
+								ranges: true,
+								// generated code contains phase imports when the experiments are on
+								importPhases: Boolean(
+									experiments.deferImport || experiments.sourceImport
+								)
+							},
+							JavascriptParser._getModuleParseFunction(this.compilation, m)
+						));
+					} catch (_err) {
+						const err =
+							/** @type {Error & { loc?: { line: number, column: number } }} */
+							(_err);
+						if (
+							err.loc &&
+							typeof err.loc === "object" &&
+							typeof err.loc.line === "number"
+						) {
+							const lineNumber = err.loc.line;
+							const lines = code.split("\n");
+							err.message += `\n| ${lines
+								.slice(Math.max(0, lineNumber - 3), lineNumber + 2)
+								.join("\n| ")}`;
+						}
+						throw err;
+					}
+					const analysis = analyzeScope(ast);
+					const resultSource = new ReplaceSource(source);
+					info.runtimeRequirements =
+						/** @type {ReadOnlyRuntimeRequirements} */
+						(codeGenResult.runtimeRequirements);
+					info.ast = ast;
+					info.internalSource = source;
+					info.source = resultSource;
+					info.chunkInitFragments = chunkInitFragments;
+					info.globalScope = analysis.globalScope;
+					info.moduleScope = analysis.moduleScope;
+					info.unresolvedReferences = analysis.unresolvedReferences;
+					info.concatenationScope = concatenationScope;
+				} catch (err) {
+					/** @type {Error} */
+					(err).message +=
+						`\nwhile analyzing module ${m.identifier()} for concatenation`;
+					throw err;
+				}
 			}
 		}
 	}
@@ -2614,17 +3097,18 @@ ${defineGetters}`
 					case "concatenated":
 						item = {
 							type: "concatenated",
+							wrapped: info.wrapped,
+							eager: false,
 							module: info.module,
 							index,
-							cjsWrapped: isCommonJsWrapped(
-								/** @type {NormalModule} */ (info.module)
-							),
+							namespaceFnName: undefined,
 							ast: undefined,
 							chunkInitFragments: undefined,
 							internalSource: undefined,
 							runtimeRequirements: undefined,
 							source: undefined,
 							globalScope: undefined,
+							unresolvedReferences: undefined,
 							moduleScope: undefined,
 							internalNames: new Map(),
 							exportMap: undefined,
@@ -2646,11 +3130,14 @@ ${defineGetters}`
 					case "external":
 						item = {
 							type: "external",
+							wrapped: info.wrapped,
+							eager: false,
 							module: info.module,
 							runtimeCondition: info.runtimeCondition,
 							nonDeferAccess: info.nonDeferAccess,
 							index,
 							name: undefined,
+							namespaceFnName: undefined,
 							escapeNamespaceObjectName: undefined,
 							deferredName: undefined,
 							interopNamespaceObjectUsed: false,
@@ -2761,4 +3248,32 @@ ConcatenatedModule.getCompilationHooks = createHooksRegistry(
 
 makeSerializable(ConcatenatedModule, "webpack/lib/optimize/ConcatenatedModule");
 
+/** @type {WeakMap<Compilation, WeakMap<Module, ConcatenatedModule>>} */
+const absorbedBy = new WeakMap();
+
+/**
+ * The module the chunk graph holds for `module`: concatenation replaces every module
+ * it absorbs with one `ConcatenatedModule`, so an absorbed module is itself in no
+ * chunk and no runtime, and asking the chunk graph about it answers about nothing.
+ * @param {Compilation} compilation the compilation
+ * @param {Module} module a module, possibly absorbed by concatenation
+ * @returns {Module} the module the chunk graph holds, or `module` itself
+ */
+ConcatenatedModule.getChunkGraphModule = (compilation, module) => {
+	let map = absorbedBy.get(compilation);
+	if (map === undefined) {
+		map = new WeakMap();
+		for (const candidate of compilation.modules) {
+			if (candidate instanceof ConcatenatedModule) {
+				for (const inner of candidate._modules) {
+					map.set(inner, candidate);
+				}
+			}
+		}
+		absorbedBy.set(compilation, map);
+	}
+	const outer = map.get(module);
+	return outer === undefined ? module : outer;
+};
+
 module.exports = ConcatenatedModule;