webpack 5.111.0 → 5.112.0

package/lib/optimize/ConcatenatedModule.js

@@ -11,26 +11,19 @@ const {
 	ConcatSource,
 	ReplaceSource
 } = require("webpack-sources");
-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 { ImportPhaseUtils } = require("../dependencies/core/ImportPhase");
+const Dependency = require("../graph/Dependency");
+const { UsageState } = require("../graph/ExportsInfo");
+const isDependencyKind = require("../graph/isDependencyKind");
 const JavascriptParser = require("../javascript/JavascriptParser");
 const analyzeScope = require("../javascript/ScopeAnalyzer");
+const Module = require("../module/Module");
+const {
+	JAVASCRIPT_TYPE,
+	JAVASCRIPT_TYPES
+} = require("../module/ModuleSourceTypeConstants");
+const { JAVASCRIPT_MODULE_TYPE_ESM } = require("../module/ModuleTypeConstants");
 const {
 	getDeferredCycleModuleIds,
 	getDeferredCycleModules,
@@ -38,6 +31,8 @@ const {
 	getMakeDeferredNamespaceModeFromExportsType,
 	getOptimizedDeferredModule
 } = require("../runtime/MakeDeferredNamespaceObjectRuntime");
+const RuntimeGlobals = require("../runtime/RuntimeGlobals");
+const Template = require("../template/Template");
 const { equals } = require("../util/ArrayHelpers");
 const LazySet = require("../util/LazySet");
 const { getBuildDiagnostics } = require("../util/buildDiagnostics");
@@ -50,7 +45,6 @@ const {
 	addScopeSymbols,
 	findNewName,
 	getAllReferences,
-	getPathInAst,
 	getUsedNamesInScopeInfo,
 	isCommonJsConcatenationEnabled
 } = require("../util/concatenate");
@@ -67,7 +61,8 @@ const {
 	runtimeConditionToString,
 	subtractRuntimeCondition
 } = require("../util/runtime");
-const { InlinedUsedName } = require("./InlineExports");
+const ConcatenationScope = require("./ConcatenationScope");
+const { isInlinedUsedName } = require("./InlineExports");
 
 /** @import { Source } from "webpack-sources" */
 /**
@@ -75,13 +70,13 @@ const { InlinedUsedName } = require("./InlineExports");
  * 	WebpackOptionsNormalizedWithDefaults as WebpackOptions
  * } from "../config/defaults"
  */
-/** @import ChunkGraph from "../ChunkGraph" */
-/** @import CodeGenerationResults from "../CodeGenerationResults" */
+/** @import ChunkGraph from "../graph/ChunkGraph" */
+/** @import CodeGenerationResults from "../module/CodeGenerationResults" */
 /** @import Compilation, { FileSystemDependencies } from "../Compilation" */
-/** @import { UpdateHashContext } from "../Dependency" */
-/** @import HarmonyImportDependency from "../dependencies/HarmonyImportDependency" */
-/** @import DependencyTemplates from "../DependencyTemplates" */
-/** @import { ExportInfo } from "../ExportsInfo" */
+/** @import { UpdateHashContext } from "../graph/Dependency" */
+/** @import ESMImportDependency from "../dependencies/esm/ESMImportDependency" */
+/** @import DependencyTemplates from "../template/DependencyTemplates" */
+/** @import { ExportInfo } from "../graph/ExportsInfo" */
 /**
  * @import {
  * 	BuildCallback,
@@ -96,18 +91,19 @@ const { InlinedUsedName } = require("./InlineExports");
  * 	NameForCondition,
  * 	ReadOnlyRuntimeRequirements,
  * 	RuntimeRequirements,
- * 	SourceTypes
- * } from "../Module"
+ * 	SourceTypes,
+ * 	ModuleKinds
+ * } from "../module/Module"
  */
-/** @import ModuleGraph from "../ModuleGraph" */
+/** @import ModuleGraph from "../graph/ModuleGraph" */
 /**
  * @import ModuleGraphConnection, {
  * 	ConnectionState
- * } from "../ModuleGraphConnection"
+ * } from "../graph/ModuleGraphConnection"
  */
-/** @import RequestShortener from "../RequestShortener" */
-/** @import { ResolverWithOptions } from "../ResolverFactory" */
-/** @import RuntimeTemplate from "../RuntimeTemplate" */
+/** @import RequestShortener from "../util/RequestShortener" */
+/** @import { ResolverWithOptions } from "../resolve/ResolverFactory" */
+/** @import RuntimeTemplate from "../template/RuntimeTemplate" */
 /**
  * @import {
  * 	JavascriptModuleBuildInfo,
@@ -130,12 +126,12 @@ const { InlinedUsedName } = require("./InlineExports");
  */
 /** @import Hash, { HashFunction } from "../util/Hash" */
 /** @import { UsedNames, UsedNamesInScopeInfo } from "../util/concatenate" */
-/** @import { InputFileSystem } from "../util/fs" */
+/** @import { InputFileSystem } from "../fs/fs" */
 /** @import { AssociatedObjectForCache } from "../util/identifier" */
 /** @import { RuntimeSpec } from "../util/runtime" */
 /**
  * @template T
- * @typedef {import("../InitFragment")<T>} InitFragment
+ * @typedef {import("../template/InitFragment")<T>} InitFragment
  */
 
 /**
@@ -206,7 +202,7 @@ const findIdentifiers = (source) => {
  * @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 {Program | undefined} ast
+ * @property {Set<number> | undefined} shorthandIdentifierStarts where each shorthand property's identifier starts
  * @property {Source | undefined} internalSource
  * @property {ReplaceSource | undefined} source
  * @property {InitFragment<ChunkRenderContext>[]=} chunkInitFragments
@@ -303,6 +299,7 @@ const compareNumbers = (a, b) => {
 
 const bySourceOrder = createComparator("sourceOrder", compareNumbers);
 const byRangeStart = createComparator("rangeStart", compareNumbers);
+const byDependencyIndex = createComparator("dependencyIndex", compareNumbers);
 
 /**
  * @param {Iterable<string>} iterable iterable object
@@ -357,7 +354,7 @@ const subtractNonDeferAccess = (a, b) => a && !b;
  * @returns {boolean} true, when the module renders wrapped
  */
 const needWrapped = (module) =>
-	module instanceof NormalModule &&
+	module.is("normal") &&
 	module.type.startsWith("javascript/") &&
 	module.buildMeta !== undefined &&
 	module.buildMeta.exportsType !== "namespace";
@@ -367,11 +364,14 @@ const needWrapped = (module) =>
  * @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());
+const entryCanBeWrapped = (entry) => {
+	// TODO in the next major release: call it directly. A module built against an older webpack
+	// extends a base class without it, so fall back to the check this replaced.
+	if (typeof entry.module.canBeWrappedInConcatenation !== "function") {
+		return !entry.module.type.startsWith("css/");
+	}
+	return entry.module.canBeWrappedInConcatenation();
+};
 
 /** @typedef {Set<ConcatenatedModuleInfo>} NeededNamespaceObjects */
 
@@ -558,12 +558,13 @@ const getFinalBinding = (
 					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.
+							// WHY: `ns.default` for a deferred default-with-named external
+							// module must read through the optimized `.a` getter, which
+							// evaluates the
+							// module lazily and returns its exports, rather than through the
+							// proxy namespace — otherwise `typeof ns.default` and
+							// `ns.default instanceof X` observe the proxy, not the actual
+							// default.
 							return {
 								info,
 								rawName: `${info.deferredName}.a`,
@@ -602,10 +603,9 @@ const getFinalBinding = (
 					};
 				}
 				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.
+					// As with default-with-named above, a deferred default-only
+					// external reads through the `.a` getter, so `typeof` and
+					// `instanceof` see the value rather than the proxy.
 					return {
 						info,
 						rawName: `${info.deferredName}.a`,
@@ -756,13 +756,12 @@ const getFinalBinding = (
 						exportName
 					};
 				}
-				if (usedName instanceof InlinedUsedName) {
+				if (isInlinedUsedName(usedName)) {
 					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`).
+						// Render the inlined literal only, not its property suffix: that
+						// comes back in `ids` and getFinalName appends it once, so emitting
+						// it here too would duplicate the access.
 						rawName: usedName.render(
 							Template.toNormalComment(
 								`inlined export ${propertyAccess(exportName)}`
@@ -799,7 +798,7 @@ const getFinalBinding = (
 					const usedName = moduleGraph
 						.getExportsInfo(target.module)
 						.getUsedName([...target.export, ...exportName.slice(1)], runtime);
-					if (usedName instanceof InlinedUsedName) {
+					if (isInlinedUsedName(usedName)) {
 						return {
 							info,
 							// Literal only; suffix is appended once via `ids` (see directExport branch).
@@ -822,9 +821,16 @@ const getFinalBinding = (
 							` * ${info.type} ${m.readableIdentifier(requestShortener)}`
 					).join("\n")}`
 				);
-			}
-			if (reexport) {
+			} else if (reexport) {
 				const refInfo = moduleToInfoMap.get(reexport.module);
+				// a CommonJS `exports.x = require()` re-export keeps raw exports semantics
+				const moduleExportsAccess =
+					reexport.connection.dependency !== null &&
+					isDependencyKind(
+						reexport.connection.dependency,
+						"commonjs-export-require"
+					);
+
 				return getFinalBinding(
 					moduleGraph,
 					/** @type {ModuleInfo} */ (refInfo),
@@ -841,7 +847,7 @@ const getFinalBinding = (
 					/** @type {BuildMeta} */
 					(info.module.buildMeta).strictHarmonyModule,
 					asiSafe,
-					false,
+					moduleExportsAccess,
 					alreadyVisited
 				);
 			}
@@ -859,7 +865,7 @@ const getFinalBinding = (
 				}
 				// an inlined export never reaches the exports object, so render the
 				// literal instead of reading the namespace
-				if (usedName instanceof InlinedUsedName) {
+				if (isInlinedUsedName(usedName)) {
 					return {
 						info,
 						// Literal only; suffix is appended once via `ids` (see directExport branch).
@@ -896,7 +902,7 @@ const getFinalBinding = (
 					exportName
 				};
 			}
-			if (used instanceof InlinedUsedName) {
+			if (isInlinedUsedName(used)) {
 				return {
 					info,
 					// Literal only; suffix is appended once via `ids` (see directExport branch).
@@ -1027,7 +1033,6 @@ const getFinalName = (
 
 /**
  * @typedef {object} ConcatenateModuleHooks
- * @property {SyncBailHook<[ConcatenatedModule, RuntimeSpec[], string, Record<string, string>], boolean>} onDemandExportsGeneration
  * @property {SyncBailHook<[Partial<ConcatenatedModuleInfo>, ConcatenatedModuleInfo], boolean | void>} concatenatedModuleInfo
  */
 
@@ -1132,6 +1137,22 @@ class ConcatenatedModule extends Module {
 		return [...this._modules];
 	}
 
+	/**
+	 * Returns the module this one was built around: itself, or the root of a scope-hoisted concatenation.
+	 * @returns {Module} the root module
+	 */
+	getRootModule() {
+		return this.rootModule;
+	}
+
+	/**
+	 * Returns the modules this one was built from: itself, or every module merged by scope hoisting.
+	 * @returns {Iterable<Module>} the source modules (do not mutate)
+	 */
+	getSourceModules() {
+		return this._modules;
+	}
+
 	/**
 	 * Returns the unique identifier used to reference this module.
 	 * @returns {string} a unique identifier of the module
@@ -1244,10 +1265,9 @@ class ConcatenatedModule extends Module {
 					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.
+			// populate codeGenerationDependencies: the inner templates are applied
+			// during this module's own codeGeneration, so what they reference must be
+			// generated by then. References back into the concat set are skipped.
 			if (m.codeGenerationDependencies !== undefined) {
 				for (const d of m.codeGenerationDependencies) {
 					const referenced =
@@ -1371,8 +1391,13 @@ class ConcatenatedModule extends Module {
 					connections.push(c);
 				}
 			}
+			/** @type {Map<Dependency, number>} */
+			const dependencyIndices = new Map();
+			for (let i = 0; i < module.dependencies.length; i++) {
+				dependencyIndices.set(module.dependencies[i], i);
+			}
 			/**
-			 * @type {{ connection: ModuleGraphConnection, sourceOrder: number, rangeStart: number | undefined, defer?: boolean }[]}
+			 * @type {{ connection: ModuleGraphConnection, sourceOrder: number, rangeStart: number | undefined, dependencyIndex: number, defer?: boolean }[]}
 			 */
 			const references = connections
 				.filter((connection) => {
@@ -1399,17 +1424,19 @@ class ConcatenatedModule extends Module {
 				})
 				.map((connection) => {
 					const dep =
-						/** @type {HarmonyImportDependency} */
+						/** @type {ESMImportDependency} */
 						(connection.dependency);
+					const dependencyIndex = dependencyIndices.get(dep);
 					return {
 						connection,
-						// 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.
+						// A require() edge carries no sourceOrder, and Infinity sorts it
+						// last. Not NaN: `compareNumbers` returns 0 against every number,
+						// which makes the comparator non-transitive.
 						sourceOrder:
 							typeof dep.sourceOrder === "number" ? dep.sourceOrder : Infinity,
 						rangeStart: dep.range && dep.range[0],
+						dependencyIndex:
+							dependencyIndex === undefined ? Infinity : dependencyIndex,
 						defer: ImportPhaseUtils.isDefer(dep.phase)
 					};
 				});
@@ -1428,8 +1455,11 @@ class ConcatenatedModule extends Module {
 			 * If there is no reexport, we have the same source.
 			 * If there is reexport, but module has side effects, this will lead to reexport module only.
 			 * If there is side-effects-free reexport, we can get simple deterministic result with range start comparison.
+			 * Re-exports of one statement share sourceOrder and have no range, so the dependency index breaks the tie.
 			 */
-			references.sort(concatComparators(bySourceOrder, byRangeStart));
+			references.sort(
+				concatComparators(bySourceOrder, byRangeStart, byDependencyIndex)
+			);
 			/** @type {Map<Module, { connection: ModuleGraphConnection, runtimeCondition: RuntimeSpec | true, nonDeferAccess: NonDeferAccess }>} */
 			const referencesMap = new Map();
 			/** @type {Module[] | undefined} */
@@ -1443,12 +1473,11 @@ class ConcatenatedModule extends Module {
 				const module = connection.module;
 				if (targets === undefined) targets = [module];
 				else if (!targets.includes(module)) targets.push(module);
+				const dependency = connection.dependency;
 				if (
-					[
-						CommonJsRequireDependency,
-						CommonJsFullRequireDependency,
-						CommonJsExportRequireDependency
-					].some((Dep) => connection.dependency instanceof Dep)
+					dependency !== null &&
+					(isDependencyKind(dependency, "commonjs-require") ||
+						isDependencyKind(dependency, "commonjs-export-require"))
 				) {
 					wrappedModules.add(module);
 				}
@@ -1704,40 +1733,38 @@ 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 }
-	 */
+	// WHY: 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 + 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 scopes 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
@@ -1803,8 +1830,8 @@ class ConcatenatedModule extends Module {
 		/** @type {Set<ConcatenatedModuleInfo | ExternalModuleInfo>} */
 		const neededEscapeNamespaceObjects = new Set();
 
-		// #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
+		// #region [1] ANALYSE: run each inner module's own codeGeneration and
+		// scope-analyse the body; a non-wrapped one keeps its scopes for [3]
 		for (const info of moduleToInfoMap.values()) {
 			this._analyseModule(
 				moduleToInfoMap,
@@ -1868,7 +1895,7 @@ class ConcatenatedModule extends Module {
 			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 || isInlinedUsedName(usedName)) continue;
 				if (usedName[usedName.length - 1] !== exportInfo.name) {
 					mangled = true;
 					break;
@@ -1901,8 +1928,18 @@ class ConcatenatedModule extends Module {
 					)) {
 						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
+					// only its free globals reach freeNames; the reference tokens among
+					// them are resolved textually below and patched the same way in [4]
+					for (const reference of /** @type {Reference[]} */ (
+						info.unresolvedReferences
+					)) {
+						const name = reference.identifier.name;
+						if (!ConcatenationScope.isModuleReference(name)) {
+							freeNames.add(name);
+						}
+					}
+					// A wrapped body's references are found textually, as [4] patches
+					// them. 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();
@@ -2108,10 +2145,9 @@ class ConcatenatedModule extends Module {
 			switch (info.type) {
 				case "concatenated": {
 					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.
+						// A wrapped module declares one shared-scope name, the lazy accessor
+						// holding its body. Stage 2 claimed that body's identifiers, so
+						// findNewName avoids the ones that would shadow it from inside.
 						const namespaceFnName = findNewName(
 							"namespaceFn",
 							allUsedNames,
@@ -2139,26 +2175,14 @@ class ConcatenatedModule extends Module {
 								for (const identifier of variable.identifiers) {
 									allIdentifiers.add(identifier);
 								}
+								const shorthandStarts =
+									/** @type {NonNullable<ConcatenatedModuleInfo["shorthandIdentifierStarts"]>} */
+									(info.shorthandIdentifierStarts);
 								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;
-										}
+									if (shorthandStarts.has(r[0])) {
+										source.insert(r[1], `: ${newName}`);
+										continue;
 									}
 									source.replace(r[0], r[1] - 1, newName);
 								}
@@ -2365,8 +2389,8 @@ 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.
+				// A wrapped body's reference tokens are found textually rather than
+				// in its AST. [2] scanned the same source, so this reuses its result.
 				/** @type {Map<string, string>} */
 				const finalNames = new Map();
 				const source = /** @type {ReplaceSource} */ (info.source);
@@ -2419,10 +2443,9 @@ class ConcatenatedModule extends Module {
 		}
 		// #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
+		// #region [5] COLLECT EXPORTS: split the root module's exports into used,
+		// unused and inlined. Used ones stay thunks, since resolving one can still
+		// register a namespace object that stage 7 must see.
 		/** @type {Map<string, (requestShortener: RequestShortener) => string>} */
 		const exportsMap = new Map();
 
@@ -2450,7 +2473,7 @@ class ConcatenatedModule extends Module {
 				unusedExports.add(name);
 				continue;
 			}
-			if (used instanceof InlinedUsedName) {
+			if (isInlinedUsedName(used)) {
 				inlinedExports.add(name);
 				continue;
 			}
@@ -2500,6 +2523,8 @@ class ConcatenatedModule extends Module {
 			shouldAddHarmonyFlag = true;
 		}
 
+		/** @type {string | undefined} */
+		let onDemandExportsSource;
 		// define exports
 		if (exportsMap.size > 0) {
 			/** @type {string[]} */
@@ -2530,17 +2555,10 @@ class ConcatenatedModule extends Module {
 					this.exportsArgument
 				}, {${definitions.join(",")}\n});\n`;
 
-			const { onDemandExportsGeneration } =
-				ConcatenatedModule.getCompilationHooks(this.compilation);
-
-			if (
-				!onDemandExportsGeneration.call(
-					this,
-					runtimes,
-					`${harmonyFlagSource}${exportsSource}`,
-					exportsFinalName
-				)
-			) {
+			const meta = moduleGraph.getMetaIfExisting(this);
+			if (meta !== undefined && meta.onDemandExports === true) {
+				onDemandExportsSource = `${harmonyFlagSource}${exportsSource}`;
+			} else {
 				result.add(harmonyFlagSource);
 				result.add(exportsSource);
 			}
@@ -2562,13 +2580,12 @@ class ConcatenatedModule extends Module {
 		// #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
-		// regular namespace objects so any nested namespace they pull in is built.
+		// and emitted by stage 8; an external's goes next to its import variable or
+		// accessor instead, defined later.
+
+		// Decoupled namespace objects for escaping mangled namespaces carry the same
+		// getters keyed by the original export names, so untracked access by name
+		// keeps working. Built first, so any nested namespace they pull in exists.
 		/** @type {Map<ConcatenatedModuleInfo | ExternalModuleInfo, string>} */
 		const escapeNamespaceObjectSources = new Map();
 		for (const info of neededEscapeNamespaceObjects) {
@@ -2579,7 +2596,7 @@ class ConcatenatedModule extends Module {
 				if (exportInfo.provided === false) continue;
 				const usedName = exportInfo.getUsedName(undefined, runtime);
 				if (!usedName) continue;
-				if (usedName instanceof InlinedUsedName) {
+				if (isInlinedUsedName(usedName)) {
 					nsObj.push(
 						`\n  ${propertyName(
 							exportInfo.name
@@ -2660,7 +2677,7 @@ ${defineGetters}`
 			for (const exportInfo of exportsInfo.orderedExports) {
 				if (exportInfo.provided === false) continue;
 				const usedName = exportInfo.getUsedName(undefined, runtime);
-				if (usedName && !(usedName instanceof InlinedUsedName)) {
+				if (usedName && !isInlinedUsedName(usedName)) {
 					const finalName = getFinalName(
 						moduleGraph,
 						info,
@@ -2730,20 +2747,31 @@ ${defineGetters}`
 		for (const info of wrappedInfos) {
 			if (info.type === "concatenated") {
 				runtimeRequirements.add(RuntimeGlobals.concatenationWrap);
+				const bodyRuntimeRequirements =
+					/** @type {ReadOnlyRuntimeRequirements} */
+					(info.runtimeRequirements);
 				result.add(
 					`\n// MODULE: ${info.module.readableIdentifier(
 						requestShortener
 					)}\nvar ${info.namespaceFnName} = /*#__PURE__*/${
 						RuntimeGlobals.concatenationWrap
-					}(function(${info.module.moduleArgument}, ${
-						info.module.exportsArgument
-					}) {\n`
+					}(${runtimeTemplate.moduleFactoryFnHeader({
+						module: info.module,
+						// the trailing `module.exports` assignment below reads it
+						needModule:
+							Boolean(info.namespaceExportSymbol) ||
+							bodyRuntimeRequirements.has(RuntimeGlobals.module),
+						needExports: bodyRuntimeRequirements.has(RuntimeGlobals.exports),
+						needRequire: false,
+						needThisAsExports: bodyRuntimeRequirements.has(
+							RuntimeGlobals.thisAsExports
+						)
+					})}\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.
+				// A generated body binds its value to a local rather than writing
+				// exports, so hand that local to the accessor. The name is verbatim: a
+				// wrapped body is not scope-analysed and keeps the reserved symbol.
 				result.add(
 					info.namespaceExportSymbol
 						? `\n${info.module.moduleArgument}.exports = ${info.namespaceExportSymbol};\n});\n`
@@ -2825,7 +2853,7 @@ ${defineGetters}`
 				result.add(
 					`\n// DEFERRED EXTERNAL MODULE: ${info.module.readableIdentifier(
 						requestShortener
-					)}\nvar ${info.deferredName} = ${loader};`
+					)}\nvar ${info.deferredName} = ${runtimeTemplate.sideEffectsAnnotation()}${loader};`
 				);
 				if (info.deferredNamespaceObjectUsed) {
 					runtimeRequirements.add(RuntimeGlobals.makeDeferredNamespaceObject);
@@ -2939,7 +2967,10 @@ ${defineGetters}`
 						// External module bindings may be wrapped in
 						// runtime-condition `if` blocks but referenced outside,
 						// so they must remain function-scoped (`var`).
-						const required = `__webpack_require__(${moduleId})`;
+						const required = `${runtimeTemplate.moduleSideEffectsAnnotation(
+							info.module,
+							moduleGraph
+						)}__webpack_require__(${moduleId})`;
 
 						// The wrapping happens per reference, so only the helper has
 						// to be declared here.
@@ -2980,9 +3011,8 @@ ${defineGetters}`
 					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.
+			// at the top level and break require() cycles, so it is deferred behind a
+			// hoisted function, memoized on the function object itself.
 			/**
 			 * @param {string} interopName interop variable name
 			 * @param {string} expr interop object expression
@@ -3034,6 +3064,10 @@ ${defineGetters}`
 		}
 		data.set("topLevelDeclarations", topLevelDeclarations);
 		data.set("freeNames", freeNames);
+		if (onDemandExportsSource !== undefined) {
+			data.set("exportsSource", onDemandExportsSource);
+			data.set("exportsFinalName", exportsFinalName);
+		}
 
 		/** @type {CodeGenerationResult} */
 		const resultEntry = {
@@ -3070,124 +3104,92 @@ ${defineGetters}`
 		codeGenerationResults,
 		usedNames
 	) {
-		if (info.type === "concatenated") {
-			const m = info.module;
-			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
-				);
-				info.concatenationScope = concatenationScope;
-				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;
-				info.runtimeRequirements =
-					/** @type {ReadOnlyRuntimeRequirements} */
-					(codeGenResult.runtimeRequirements);
-				info.internalSource = source;
-				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
-					);
+		if (info.type !== "concatenated") return;
+		const m = info.module;
+		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;
+			// 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,
+					{
+						// a wrapped CommonJS body may `return` at its top level
+						sourceType: info.wrapped ? "auto" : "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);
+			info.runtimeRequirements =
+				/** @type {ReadOnlyRuntimeRequirements} */
+				(codeGenResult.runtimeRequirements);
+			info.internalSource = source;
+			info.source = new ReplaceSource(source);
+			info.chunkInitFragments = chunkInitFragments;
+			info.unresolvedReferences = analysis.unresolvedReferences;
+			info.concatenationScope = concatenationScope;
+			// the wrapper isolates the body's declarations, so [3] renames nothing in
+			// it and its scopes are not kept; [2] claims its identifiers textually
+			if (info.wrapped) return;
+			info.shorthandIdentifierStarts = analysis.shorthandIdentifierStarts;
+			info.globalScope = analysis.globalScope;
+			info.moduleScope = analysis.moduleScope;
+		} catch (err) {
+			/** @type {Error} */
+			(err).message +=
+				`\nwhile analyzing module ${m.identifier()} for concatenation`;
+			throw err;
 		}
 	}
 
@@ -3217,7 +3219,7 @@ ${defineGetters}`
 							module: info.module,
 							index,
 							namespaceFnName: undefined,
-							ast: undefined,
+							shorthandIdentifierStarts: undefined,
 							chunkInitFragments: undefined,
 							internalSource: undefined,
 							runtimeRequirements: undefined,
@@ -3334,13 +3336,10 @@ ${defineGetters}`
 	 * @returns {ConcatenatedModule} ConcatenatedModule
 	 */
 	static deserialize(context) {
-		const obj = new ConcatenatedModule({
-			identifier: /** @type {EXPECTED_ANY} */ (undefined),
-			rootModule: /** @type {EXPECTED_ANY} */ (undefined),
-			modules: /** @type {EXPECTED_ANY} */ (undefined),
-			runtime: undefined,
-			compilation: /** @type {EXPECTED_ANY} */ (undefined)
-		});
+		const obj = new ConcatenatedModule(
+			// every field is restored by `deserialize` and `updateCacheModule`
+			/** @type {ConstructorParameters<typeof ConcatenatedModule>[0]} */ ({})
+		);
 		obj.deserialize(context);
 		return obj;
 	}
@@ -3349,12 +3348,6 @@ ${defineGetters}`
 ConcatenatedModule.getCompilationHooks = createHooksRegistry(
 	() =>
 		/** @type {ConcatenateModuleHooks} */ ({
-			onDemandExportsGeneration: new SyncBailHook([
-				"module",
-				"runtimes",
-				"exportsFinalName",
-				"exportsSource"
-			]),
 			concatenatedModuleInfo: new SyncBailHook([
 				"updatedInfo",
 				"concatenatedModuleInfo"
@@ -3364,6 +3357,9 @@ ConcatenatedModule.getCompilationHooks = createHooksRegistry(
 
 makeSerializable(ConcatenatedModule, "webpack/lib/optimize/ConcatenatedModule");
 
+/** @type {Set<keyof ModuleKinds>} */
+ConcatenatedModule.KINDS = new Set([...Module.KINDS, "concatenated"]);
+
 /** @type {WeakMap<Compilation, WeakMap<Module, ConcatenatedModule>>} */
 const absorbedBy = new WeakMap();
 
@@ -3380,7 +3376,7 @@ ConcatenatedModule.getChunkGraphModule = (compilation, module) => {
 	if (map === undefined) {
 		map = new WeakMap();
 		for (const candidate of compilation.modules) {
-			if (candidate instanceof ConcatenatedModule) {
+			if (candidate.is("concatenated")) {
 				for (const inner of candidate._modules) {
 					map.set(inner, candidate);
 				}