webpack 5.111.0 → 5.112.0

package/lib/javascript/JavascriptModulesPlugin.js

@@ -22,19 +22,20 @@ const {
  * 	WebpackRequire
  * } from "../Compilation"
  */
-const HotUpdateChunk = require("../HotUpdateChunk");
-const InitFragment = require("../InitFragment");
-const { JAVASCRIPT_TYPE } = require("../ModuleSourceTypeConstants");
+const ConflictingEntryExportsWarning = require("../errors/ConflictingEntryExportsWarning");
+const { tryRunOrWebpackError } = require("../errors/HookWebpackError");
+const UnmergeableEntryExportsError = require("../errors/UnmergeableEntryExportsError");
+const { JAVASCRIPT_TYPE } = require("../module/ModuleSourceTypeConstants");
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
 	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
 	JAVASCRIPT_MODULE_TYPE_ESM,
 	WEBPACK_MODULE_TYPE_RUNTIME
-} = require("../ModuleTypeConstants");
-const NormalModule = require("../NormalModule");
-const RuntimeGlobals = require("../RuntimeGlobals");
-const Template = require("../Template");
-const { tryRunOrWebpackError } = require("../errors/HookWebpackError");
+} = require("../module/ModuleTypeConstants");
+const NormalModule = require("../module/NormalModule");
+const RuntimeGlobals = require("../runtime/RuntimeGlobals");
+const InitFragment = require("../template/InitFragment");
+const Template = require("../template/Template");
 const { last, someInIterable } = require("../util/IterableHelpers");
 const StringXor = require("../util/StringXor");
 const { compareModulesByFullName } = require("../util/comparators");
@@ -44,43 +45,46 @@ const {
 	addScopeSymbols,
 	findNewName,
 	getAllReferences,
-	getPathInAst,
 	getUsedNamesInScopeInfo
 } = require("../util/concatenate");
 const createHash = require("../util/createHash");
 const createHooksRegistry = require("../util/createHooksRegistry");
 const { digestNonNumericOnlyWithFull } = require("../util/nonNumericOnlyHash");
+const { propertyAccess } = require("../util/property");
 const { removeBOMFromResult } = require("../util/removeBOM");
 const { intersectRuntime } = require("../util/runtime");
 const { getAllChunks } = require("./ChunkHelpers");
 const JavascriptGenerator = require("./JavascriptGenerator");
 const JavascriptModule = require("./JavascriptModule");
 const JavascriptParser = require("./JavascriptParser");
+const {
+	compilationMergesEntryExports,
+	getMergedExports,
+	mergedEntryModules,
+	mergedEntryModulesOfLibrary
+} = require("./MergedEntryExports");
 const analyzeScope = require("./ScopeAnalyzer");
-const { renderAwaitedEntries } = require("./StartupHelpers");
-const { releaseParserCaches } = require("./syntax");
+const {
+	entryStartupAwaitsChunks,
+	renderAwaitedEntries
+} = require("./StartupHelpers");
+const { releaseParserCaches } = require("./syntax-parser");
 
-/**
- * @import {
- * 	Program
- * } from "estree"
- */
 /** @import { Source } from "webpack-sources" */
 /**
  * @import {
  * 	OutputNormalizedWithDefaults as OutputOptions
  * } from "../config/defaults"
  */
-/** @import Chunk, { ChunkFilenameTemplate } from "../Chunk" */
-/** @import ChunkGraph, { EntryModuleWithChunkGroup } from "../ChunkGraph" */
-/** @import CodeGenerationResults from "../CodeGenerationResults" */
+/** @import Chunk, { ChunkFilenameTemplate } from "../graph/Chunk" */
+/** @import ChunkGraph, { EntryModuleWithChunkGroup } from "../graph/ChunkGraph" */
+/** @import CodeGenerationResults from "../module/CodeGenerationResults" */
 /** @import Compiler from "../Compiler" */
-/** @import DependencyTemplates from "../DependencyTemplates" */
-/** @import Entrypoint from "../Entrypoint" */
-/** @import Module, { BuildInfo, CodeGenerationResultData } from "../Module" */
-/** @import { RuntimeSpec } from "../util/runtime" */
-/** @import ModuleGraph from "../ModuleGraph" */
-/** @import RuntimeTemplate from "../RuntimeTemplate" */
+/** @import DependencyTemplates from "../template/DependencyTemplates" */
+/** @import Entrypoint from "../graph/Entrypoint" */
+/** @import Module, { BuildInfo, CodeGenerationResultData } from "../module/Module" */
+/** @import ModuleGraph from "../graph/ModuleGraph" */
+/** @import RuntimeTemplate from "../template/RuntimeTemplate" */
 /** @import WebpackError from "../errors/WebpackError" */
 /** @import { Range } from "../javascript/JavascriptParser" */
 /** @import Hash from "../util/Hash" */
@@ -254,6 +258,8 @@ const printGeneratedCodeForStack = (module, code) => {
  * @property {boolean=} inlined inlined
  * @property {boolean=} inlinedInIIFE the inlined entry module is wrapped in an IIFE
  * @property {boolean=} needExportsDeclaration whether the top-level exports declaration needs to be generated
+ * @property {Map<string, string>=} renamedDeclarations the inlined entry's top-level declarations renamed to avoid a collision, original to new name
+ * @property {boolean=} exportsAwaited the startup already awaited the last entry, so `__webpack_exports__` holds its settled exports
  */
 
 /**
@@ -332,18 +338,6 @@ const createCompilationHooks = () => ({
 	 * @since 5.22.0
 	 */
 	inlineInRuntimeBailout: new SyncBailHook(["module", "renderContext"]),
-	/**
-	 * Offers a module's rendered export-definition call to a consumer that can place
-	 * it better — a library whose entry exports the same bindings natively takes it
-	 * over and emits it only where the module is wrapped. Return true to take it.
-	 * @type {SyncBailHook<[Module, RuntimeSpec, string, boolean], boolean | void>}
-	 */
-	onDemandExportsGeneration: new SyncBailHook([
-		"module",
-		"runtime",
-		"source",
-		"placeAtEnd"
-	]),
 	/**
 	 * @type {SyncBailHook<[Module, RenderContext], string | void>}
 	 * @since 5.22.0
@@ -375,20 +369,22 @@ const createCompilationHooks = () => ({
  * in `allUsedNames`. Lets inlined modules be emitted without a per-entry/per-chunk
  * IIFE by resolving name collisions instead of isolating each module.
  * @param {InstanceType<typeof import("webpack-sources").ReplaceSource>} source the module source to edit
- * @param {Program} ast the parsed module AST
+ * @param {Set<number>} shorthandIdentifierStarts where each shorthand property's identifier starts
  * @param {Variable} variable the top-level variable to check/rename
  * @param {string} moduleIdentifier the module identifier (for scope caching)
  * @param {string} readableIdentifier the readable module identifier (for new names)
  * @param {Set<string>} allUsedNames names already used in the shared scope (mutated)
+ * @param {Map<string, string>} renamedDeclarations the declarations renamed so far, original to new name (mutated)
  * @returns {void}
  */
 const renameInlinedModuleVariable = (
 	source,
-	ast,
+	shorthandIdentifierStarts,
 	variable,
 	moduleIdentifier,
 	readableIdentifier,
-	allUsedNames
+	allUsedNames,
+	renamedDeclarations
 ) => {
 	/** @type {UsedNamesInScopeInfo} */
 	const usedNamesInScopeInfo = new Map();
@@ -419,18 +415,12 @@ const renameInlinedModuleVariable = (
 			readableIdentifier
 		);
 		allUsedNames.add(newName);
+		renamedDeclarations.set(name, newName);
 		for (const identifier of allIdentifiers) {
 			const r = /** @type {Range} */ (identifier.range);
-			const path = getPathInAst(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 (shorthandIdentifierStarts.has(r[0])) {
+				source.insert(r[1], `: ${newName}`);
+				continue;
 			}
 			source.replace(r[0], r[1] - 1, newName);
 		}
@@ -440,13 +430,28 @@ const renameInlinedModuleVariable = (
 
 const PLUGIN_NAME = "JavascriptModulesPlugin";
 
-/** @typedef {{ header: string[], beforeStartup: string[], startup: string[], afterStartup: string[], allowInlineStartup: boolean }} Bootstrap */
+// Drops the redundant string/buffer copy of a source, keeping its map: a
+// parsed map is far more expensive to rebuild than a `toString`.
+const CLEAR_SOURCE_COPIES = { maps: false, source: true };
+
+/** @typedef {{ header: string[], beforeStartup: string[], startup: string[], afterStartup: string[], allowInlineStartup: boolean, exportsAwaited: boolean }} Bootstrap */
+/** @typedef {{ source: Source, needModule: boolean, needExports: boolean, needRequire: boolean, needThisAsExports: boolean, needStrict: boolean | undefined, renderShorthand: boolean, next: ModuleFactoryCacheEntry | undefined }} ModuleFactoryCacheEntry */
+
+/**
+ * @typedef {object} RenamedInlinedModules
+ * @property {Map<Module, Source>} sources each inlined module's rendered source, renamed where it collided
+ * @property {Map<Module, Map<string, string>>} renamedDeclarations each renamed module's declarations, original to new name
+ */
 
 class JavascriptModulesPlugin {
 	constructor(options = {}) {
 		this.options = options;
-		/** @type {WeakMap<Source, { source: Source, needModule: boolean, needExports: boolean, needRequire: boolean, needThisAsExports: boolean, needStrict: boolean | undefined, renderShorthand: boolean }>} */
+		/** @type {WeakMap<Source, ModuleFactoryCacheEntry>} */
 		this._moduleFactoryCache = new WeakMap();
+		/** @type {WeakMap<Source, Set<string>>} */
+		this._renderedFreeNamesCache = new WeakMap();
+		/** @type {WeakMap<CodeGenerationResults, Set<Source>>} */
+		this._renderedModuleFactorySources = new WeakMap();
 	}
 
 	/**
@@ -459,6 +464,9 @@ class JavascriptModulesPlugin {
 		// drop them when the build ends so an idle process retains no parser state
 		compiler.hooks.done.tap(PLUGIN_NAME, releaseParserCaches);
 		compiler.hooks.failed.tap(PLUGIN_NAME, releaseParserCaches);
+		compiler.hooks.afterEmit.tap(PLUGIN_NAME, (compilation) => {
+			this._releaseRenderedModuleFactorySources(compilation);
+		});
 		compiler.hooks.compilation.tap(
 			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
@@ -534,7 +542,7 @@ class JavascriptModulesPlugin {
 						codeGenerationResults
 					} = options;
 
-					const hotUpdateChunk = chunk instanceof HotUpdateChunk ? chunk : null;
+					const hotUpdateChunk = chunk.isHotUpdate() ? chunk : null;
 					const filenameTemplate =
 						JavascriptModulesPlugin.getChunkFilenameTemplate(
 							chunk,
@@ -703,16 +711,93 @@ class JavascriptModulesPlugin {
 				compilation.hooks.additionalTreeRuntimeRequirements.tap(
 					PLUGIN_NAME,
 					(chunk, set, { chunkGraph }) => {
-						if (
-							!set.has(RuntimeGlobals.startupNoDefault) &&
-							chunkGraph.hasChunkEntryDependentChunks(chunk)
-						) {
+						if (set.has(RuntimeGlobals.startupNoDefault)) return;
+						if (chunkGraph.hasChunkEntryDependentChunks(chunk)) {
 							set.add(RuntimeGlobals.onChunksLoaded);
 							set.add(RuntimeGlobals.exports);
 							set.add(RuntimeGlobals.require);
+							return;
+						}
+						const merged = mergedEntryModules(chunk, chunkGraph, compilation);
+						if (merged === undefined) return;
+						const { exports, namespace } = getMergedExports(
+							merged,
+							compilation.moduleGraph,
+							chunk.runtime
+						);
+						set.add(RuntimeGlobals.exports);
+						if (namespace) set.add(RuntimeGlobals.makeNamespaceObject);
+						if (exports.length > 0) {
+							set.add(RuntimeGlobals.definePropertyGetters);
+							set.add(RuntimeGlobals.definePropertyGettersFromArray);
 						}
 					}
 				);
+				compilation.hooks.afterChunks.tap(PLUGIN_NAME, (chunks) => {
+					if (!compilationMergesEntryExports(compilation)) return;
+					const { chunkGraph, moduleGraph, runtimeTemplate } = compilation;
+					for (const chunk of chunks) {
+						const merged = mergedEntryModules(chunk, chunkGraph, compilation);
+						if (merged === undefined) continue;
+						// Merging reads each entry back right after it ran, which
+						// only the bootstrap of the runtime-carrying chunk can do.
+						if (
+							!chunk.hasRuntime() ||
+							chunkGraph.hasChunkEntryDependentChunks(chunk) ||
+							entryStartupAwaitsChunks(chunkGraph, chunk)
+						) {
+							compilation.errors.push(
+								new UnmergeableEntryExportsError(
+									chunk,
+									"they don't all run when this chunk starts up"
+								)
+							);
+							continue;
+						}
+						// An async entry hands back a promise the merged object would
+						// read names off, so it has to be awaited before the merge.
+						if (
+							!(
+								runtimeTemplate.isModule() &&
+								runtimeTemplate.supportsTopLevelAwait()
+							) &&
+							merged.some((module) => moduleGraph.isAsync(module))
+						) {
+							compilation.errors.push(
+								new UnmergeableEntryExportsError(
+									chunk,
+									"one of them is async and this output can't await it at the top level (see 'output.environment.topLevelAwait')"
+								)
+							);
+							continue;
+						}
+						const { conflicting, unknownExports } = getMergedExports(
+							merged,
+							moduleGraph,
+							chunk.runtime
+						);
+						if (unknownExports.length > 0) {
+							compilation.errors.push(
+								new UnmergeableEntryExportsError(
+									chunk,
+									`webpack can't tell what ${unknownExports
+										.map((module) =>
+											module.readableIdentifier(
+												runtimeTemplate.requestShortener
+											)
+										)
+										.join(", ")} exports`
+								)
+							);
+							continue;
+						}
+						if (conflicting.length > 0) {
+							compilation.warnings.push(
+								new ConflictingEntryExportsWarning(chunk, conflicting)
+							);
+						}
+					}
+				});
 				compilation.hooks.executeModule.tap(PLUGIN_NAME, (options, context) => {
 					const source =
 						options.codeGenerationResult.sources.get(JAVASCRIPT_TYPE);
@@ -790,7 +875,7 @@ class JavascriptModulesPlugin {
 	static getChunkFilenameTemplate(chunk, outputOptions) {
 		if (chunk.filenameTemplate) {
 			return chunk.filenameTemplate;
-		} else if (chunk instanceof HotUpdateChunk) {
+		} else if (chunk.isHotUpdate()) {
 			return outputOptions.hotUpdateChunkFilename;
 		}
 		const entryOptions = chunk.getEntryOptions();
@@ -804,6 +889,39 @@ class JavascriptModulesPlugin {
 		return outputOptions.chunkFilename;
 	}
 
+	/**
+	 * Releases the flattened text the module factory sources memoized while the
+	 * chunk assets were read. Clearing is only a hint, so a later read re-renders.
+	 * @param {Compilation} compilation the compilation that emitted its assets
+	 * @returns {void}
+	 */
+	_releaseRenderedModuleFactorySources(compilation) {
+		// A child compiler never inherits `afterEmit` and its assets are copied
+		// into this compilation, which keeps the child reachable through
+		// `children`, so the parent's emit is where its sources are released too.
+		for (const child of compilation.children) {
+			this._releaseRenderedModuleFactorySources(child);
+		}
+		const { codeGenerationResults } = compilation;
+		if (codeGenerationResults === undefined) return;
+		const renderedSources = this._renderedModuleFactorySources.get(
+			codeGenerationResults
+		);
+		if (renderedSources === undefined) return;
+		this._renderedModuleFactorySources.delete(codeGenerationResults);
+		// WHY: the factory sources wrap the code generation ones, so one walk with
+		// a shared `visited` clears both layers and reaches a source shared by
+		// several chunks once. Feature-detected, since `clearCache` landed in
+		// webpack-sources 3.5 and a plugin may hand us an older `Source`.
+		/** @type {WeakSet<Source>} */
+		const visited = new WeakSet();
+		for (const source of renderedSources) {
+			if (typeof source.clearCache === "function") {
+				source.clearCache(CLEAR_SOURCE_COPIES, visited);
+			}
+		}
+	}
+
 	/**
 	 * Renders the newly generated source from rendering.
 	 * @param {Module} module the rendered module
@@ -856,54 +974,41 @@ class JavascriptModulesPlugin {
 				const needStrict =
 					/** @type {BuildInfo} */
 					(module.buildInfo).strict && !strictMode;
+				const renderShorthand =
+					renderInObject === true && runtimeTemplate.supportsMethodShorthand();
 				const cacheEntry = this._moduleFactoryCache.get(
 					moduleSourcePostContent
 				);
-				const renderShorthand =
-					renderInObject === true && runtimeTemplate.supportsMethodShorthand();
-				/** @type {Source} */
+				/** @type {Source | undefined} */
 				let source;
-				if (
-					cacheEntry &&
-					cacheEntry.needModule === needModule &&
-					cacheEntry.needExports === needExports &&
-					cacheEntry.needRequire === needRequire &&
-					cacheEntry.needThisAsExports === needThisAsExports &&
-					cacheEntry.needStrict === needStrict &&
-					cacheEntry.renderShorthand === renderShorthand
-				) {
-					source = cacheEntry.source;
-				} else {
-					const factorySource = new ConcatSource();
-					/** @type {string[]} */
-					const args = [];
-					if (needExports || needRequire || needModule) {
-						args.push(
-							needModule
-								? module.moduleArgument
-								: `__unused_webpack_${module.moduleArgument}`
-						);
-					}
-					if (needExports || needRequire) {
-						args.push(
-							needExports
-								? module.exportsArgument
-								: `__unused_webpack_${module.exportsArgument}`
-						);
-					}
-					if (needRequire) args.push(RuntimeGlobals.require);
-
-					if (renderShorthand) {
-						// we can optimize function to methodShorthand if render module factory in object
-						factorySource.add(`(${args.join(", ")}) {\n\n`);
-					} else if (
-						!needThisAsExports &&
-						runtimeTemplate.supportsArrowFunction()
+				// The chunk renders a method shorthand where the entry-IIFE rename
+				// needs a standalone function, so a source can have both shapes.
+				for (let entry = cacheEntry; entry; entry = entry.next) {
+					if (
+						entry.needModule === needModule &&
+						entry.needExports === needExports &&
+						entry.needRequire === needRequire &&
+						entry.needThisAsExports === needThisAsExports &&
+						entry.needStrict === needStrict &&
+						entry.renderShorthand === renderShorthand
 					) {
-						factorySource.add(`/***/ ((${args.join(", ")}) => {\n\n`);
-					} else {
-						factorySource.add(`/***/ (function(${args.join(", ")}) {\n\n`);
+						source = entry.source;
+						break;
 					}
+				}
+				if (source === undefined) {
+					const factorySource = new ConcatSource();
+					const header = runtimeTemplate.moduleFactoryFnHeader({
+						module,
+						needModule,
+						needExports,
+						needRequire,
+						needThisAsExports,
+						shorthand: renderShorthand
+					});
+					factorySource.add(
+						renderShorthand ? `${header}\n\n` : `/***/ (${header}\n\n`
+					);
 
 					if (needStrict) {
 						factorySource.add('"use strict";\n');
@@ -918,9 +1023,23 @@ class JavascriptModulesPlugin {
 						needRequire,
 						needThisAsExports,
 						needStrict,
-						renderShorthand
+						renderShorthand,
+						next: cacheEntry
 					});
 				}
+				// Also on a cache hit: this compilation reads the assets again, so it
+				// memoizes into a source an earlier one already released.
+				let renderedSources = this._renderedModuleFactorySources.get(
+					codeGenerationResults
+				);
+				if (renderedSources === undefined) {
+					renderedSources = new Set();
+					this._renderedModuleFactorySources.set(
+						codeGenerationResults,
+						renderedSources
+					);
+				}
+				renderedSources.add(source);
 				moduleSourcePostContainer = tryRunOrWebpackError(
 					() => hooks.renderModuleContainer.call(source, module, renderContext),
 					"JavascriptModulesPlugin.getCompilationHooks().renderModuleContainer"
@@ -980,10 +1099,8 @@ class JavascriptModulesPlugin {
 		// ESM entry chunk whose runtime lives in a separate chunk: inline the
 		// single entry module at the top level (instead of the module registry)
 		// so its own top-level declarations stay live ESM bindings for consumers.
-		const inlinedEntryModule = this._getEsmEntryModuleToInline(
-			renderContext,
-			allModules
-		);
+		const inlinedEntryModule =
+			JavascriptModulesPlugin._getEsmEntryModuleToInline(renderContext);
 		let registryModules = allModules;
 		if (inlinedEntryModule) {
 			const inlinedEntrySource = this.renderModule(
@@ -1049,18 +1166,20 @@ class JavascriptModulesPlugin {
 	 * its exports as live ESM bindings. Only a self-contained ESM entry whose
 	 * top-level declarations can be lifted into the chunk scope qualifies;
 	 * otherwise `undefined` is returned and the registry path is used.
-	 * @param {RenderContext} renderContext render context
-	 * @param {Module[]} allModules all javascript modules of the chunk
+	 *
+	 * Static so that a plugin can decide before the chunk is rendered what it may
+	 * leave out of the inlined entry's source and put back in the registry.
+	 * @param {Pick<RenderContext, "chunk" | "chunkGraph" | "moduleGraph" | "runtimeTemplate" | "codeGenerationResults">} context chunk, graphs and code generation results
 	 * @returns {Module | undefined} the entry module to inline, if any
 	 */
-	_getEsmEntryModuleToInline(renderContext, allModules) {
+	static _getEsmEntryModuleToInline(context) {
 		const {
 			chunk,
 			chunkGraph,
 			moduleGraph,
 			runtimeTemplate,
 			codeGenerationResults
-		} = renderContext;
+		} = context;
 
 		// Only a single ESM entry whose runtime lives in a separate chunk.
 		if (
@@ -1285,7 +1404,7 @@ class JavascriptModulesPlugin {
 			const startupSource = new ConcatSource();
 
 			const avoidEntryIife = compilation.options.optimization.avoidEntryIife;
-			/** @type {Map<Module, Source> | false} */
+			/** @type {RenamedInlinedModules | false} */
 			let renamedInlinedModule = false;
 			let inlinedInIIFE = false;
 
@@ -1329,7 +1448,7 @@ class JavascriptModulesPlugin {
 				}
 
 				const renderedModule = renamedInlinedModule
-					? renamedInlinedModule.get(m)
+					? renamedInlinedModule.sources.get(m)
 					: this.renderModule(
 							m,
 							{
@@ -1386,7 +1505,10 @@ class JavascriptModulesPlugin {
 				...renderContext,
 				inlined: true,
 				inlinedInIIFE,
-				needExportsDeclaration: runtimeRequirements.has(RuntimeGlobals.exports)
+				needExportsDeclaration: runtimeRequirements.has(RuntimeGlobals.exports),
+				renamedDeclarations: renamedInlinedModule
+					? renamedInlinedModule.renamedDeclarations.get(lastInlinedModule)
+					: undefined
 			};
 			let renderedStartup = hooks.renderStartup.call(
 				startupSource,
@@ -1448,7 +1570,8 @@ class JavascriptModulesPlugin {
 							{
 								...renderContext,
 								inlined: false,
-								needExportsDeclaration: true
+								needExportsDeclaration: true,
+								exportsAwaited: bootstrap.exportsAwaited
 							}
 						),
 						toSource(bootstrap.afterStartup, "webpack/after-startup"),
@@ -1560,14 +1683,15 @@ class JavascriptModulesPlugin {
 			requireFunction || interceptModuleExecution || moduleUsed;
 
 		/**
-		 * @type {{ startup: string[], beforeStartup: string[], header: string[], afterStartup: string[], allowInlineStartup: boolean }}
+		 * @type {Bootstrap}
 		 */
 		const result = {
 			header: [],
 			beforeStartup: [],
 			startup: [],
 			afterStartup: [],
-			allowInlineStartup: true
+			allowInlineStartup: true,
+			exportsAwaited: false
 		};
 
 		const { header: buf, startup, beforeStartup, afterStartup } = result;
@@ -1597,17 +1721,14 @@ class JavascriptModulesPlugin {
 		}
 
 		if (runtimeRequirements.has(RuntimeGlobals.makeDeferredNamespaceObject)) {
-			// in order to optimize of DeferredNamespaceObject, we remove all proxy handlers after the module initialize
-			// (see MakeDeferredNamespaceObjectRuntimeModule)
-			// This requires all deferred imports to a module can get the module export object before the module
-			// is evaluated.
+			// The deferred namespace drops its proxy handlers once the module has
+			// initialized, which needs every deferred import of it to reach the exports
+			// object before evaluation.
 			buf.push("// The deferred module cache");
 			buf.push(`${bootstrapCst} __webpack_module_deferred_exports__ = {};`);
-			// Per the TC39 import-defer spec, every defer-import call site for
-			// the same module must yield the same Deferred Module Namespace
-			// Exotic Object (and a distinct one from any eager namespace).
-			// Cache the deferred namespace proxy here so calls from different
-			// files share identity.
+			// Every defer-import site for one module must yield the same Deferred
+			// Module Namespace, distinct from any eager one, so the proxy is cached
+			// here for call sites in different files to share.
 			buf.push("// The deferred namespace cache");
 			buf.push(
 				`${bootstrapCst} __webpack_module_deferred_namespace_cache__ = {};`
@@ -1674,22 +1795,32 @@ class JavascriptModulesPlugin {
 					entryOptions && entryOptions.library !== undefined
 						? entryOptions.library
 						: runtimeTemplate.outputOptions.library;
-				// A module library awaits the entry itself, in `ModuleLibraryPlugin`.
-				const awaitedByLibrary =
-					library !== undefined && library.type === "module";
+				const mergedModules = mergedEntryModulesOfLibrary(
+					library,
+					chunk,
+					chunkGraph
+				);
+				const merge = mergedModules !== undefined;
 				// `await` is legal only at an ESM chunk's top level, never in the
 				// startup function below, and only where the target parses it.
 				const canAwaitEntry =
 					runtimeTemplate.isModule() &&
 					runtimeTemplate.supportsTopLevelAwait() &&
-					!awaitedByLibrary &&
 					!runtimeRequirements.has(RuntimeGlobals.startup) &&
 					!(
 						runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore) &&
 						runtimeRequirements.has(RuntimeGlobals.startupOnlyAfter)
 					);
+				if (merge && result.allowInlineStartup) {
+					buf2.push(
+						"// The exports of the entry modules are merged so they can't be inlined"
+					);
+					result.allowInlineStartup = false;
+				}
 				/** @type {string[]} */
 				const awaitedEntries = [];
+				/** @type {Map<Module, string>} */
+				const mergedTargets = new Map();
 				let i = jsEntries.length;
 				for (const [entryModule, entrypoint] of jsEntries) {
 					const chunks =
@@ -1718,6 +1849,12 @@ class JavascriptModulesPlugin {
 						buf2.push(
 							"// This entry module is referenced by other modules so it can't be inlined"
 						);
+						// Its exports are then read off the exports object, and a property
+						// read is not something a consumer of the bundle can drop.
+						runtimeTemplate.analyzableBailout(
+							entryModule,
+							"the entry is referenced by other modules, so its exports are read off the exports object and a consumer cannot drop them"
+						);
 						result.allowInlineStartup = false;
 					}
 
@@ -1797,32 +1934,36 @@ class JavascriptModulesPlugin {
 						result.allowInlineStartup = false;
 					}
 
-					// `__webpack_exports__` may be reassigned later — by the
-					// `onChunksLoaded` wrapper below, by an inlined entry
-					// module that uses top-level `await` (the emitted
-					// bridge reassigns `__webpack_exports__` to the awaited
-					// value), or by other downstream codegen. Always declare
-					// with `let` (or `var` if `let` is unsupported) so
-					// reassignment is allowed.
+					// `__webpack_exports__` may be reassigned later, by the
+					// `onChunksLoaded` wrapper, a top-level `await` bridge or other
+					// codegen, so it is never declared as a constant.
 					const exportsDecl = runtimeTemplate.renderLet();
+					// Merging reads every entry back, so each one needs a variable of
+					// its own; without it only the last entry (`i === 0`) is exported.
+					const target =
+						i === 0 && !merge
+							? RuntimeGlobals.exports
+							: `${RuntimeGlobals.exports}_${i}`;
+					if (merge) mergedTargets.set(entryModule, target);
 					if (chunks.length > 0) {
 						const awaitEntry =
 							canAwaitEntry && moduleGraph.isAsync(entryModule);
-						const target =
-							i === 0
-								? RuntimeGlobals.exports
-								: `${RuntimeGlobals.exports}_${i}`;
 						// The wrapper hands back nothing until the flush below runs the
-						// entry, so an awaited one is caught by the entry call itself.
-						if (awaitEntry && i !== 0) buf2.push(`${exportsDecl} ${target};`);
+						// entry, so a captured one is caught by the entry call itself.
+						const capture = awaitEntry || merge;
+						if (capture && target !== RuntimeGlobals.exports) {
+							buf2.push(`${exportsDecl} ${target};`);
+						}
 						const entryCall = `${RuntimeGlobals.require}(${moduleIdExpr})`;
 						buf2.push(
-							`${i === 0 ? `${exportsDecl} ${RuntimeGlobals.exports} = ` : ""}${
-								RuntimeGlobals.onChunksLoaded
-							}(undefined, ${JSON.stringify(
+							`${
+								i === 0 && !merge
+									? `${exportsDecl} ${RuntimeGlobals.exports} = `
+									: ""
+							}${RuntimeGlobals.onChunksLoaded}(undefined, ${JSON.stringify(
 								chunks.map((c) => c.id)
 							)}, ${runtimeTemplate.returningFunction(
-								awaitEntry ? `(${target} = ${entryCall})` : entryCall
+								capture ? `(${target} = ${entryCall})` : entryCall
 							)})`
 						);
 						if (awaitEntry) awaitedEntries.push(target);
@@ -1831,18 +1972,14 @@ class JavascriptModulesPlugin {
 						// which orphans its rejection.
 						const awaitEntry =
 							canAwaitEntry && moduleGraph.isAsync(entryModule);
-						const target =
-							i === 0
-								? RuntimeGlobals.exports
-								: `${RuntimeGlobals.exports}_${i}`;
-						const needsDecl = i === 0 || awaitEntry;
+						const needsDecl = i === 0 || awaitEntry || merge;
 						buf2.push(
 							`${needsDecl ? `${exportsDecl} ${target} = ` : ""}${RuntimeGlobals.require}(${moduleIdExpr});`
 						);
 						if (awaitEntry) awaitedEntries.push(target);
 					} else {
-						if (i === 0) {
-							buf2.push(`${exportsDecl} ${RuntimeGlobals.exports} = {};`);
+						if (i === 0 || merge) {
+							buf2.push(`${exportsDecl} ${target} = {};`);
 						}
 						const needThisAsExports = entryRuntimeRequirements.has(
 							RuntimeGlobals.thisAsExports
@@ -1854,7 +1991,7 @@ class JavascriptModulesPlugin {
 							requireScopeUsed ||
 							entryRuntimeRequirements.has(RuntimeGlobals.exports)
 						) {
-							const exportsArg = i === 0 ? RuntimeGlobals.exports : "{}";
+							const exportsArg = i === 0 || merge ? target : "{}";
 							args.push("0", exportsArg);
 							if (requireScopeUsed) {
 								args.push(RuntimeGlobals.require);
@@ -1866,7 +2003,7 @@ class JavascriptModulesPlugin {
 									if (needThisAsExports) {
 										const comma = args.length ? "," : "";
 										return `__webpack_modules__[${moduleIdExpr}].call(${
-											RuntimeGlobals.exports
+											merge ? target : RuntimeGlobals.exports
 										}${comma}${args.join(",")});`;
 									}
 									return `__webpack_modules__[${moduleIdExpr}](${args.join(
@@ -1879,10 +2016,43 @@ class JavascriptModulesPlugin {
 				}
 				if (runtimeRequirements.has(RuntimeGlobals.onChunksLoaded)) {
 					buf2.push(
-						`${RuntimeGlobals.exports} = ${RuntimeGlobals.onChunksLoaded}(${RuntimeGlobals.exports});`
+						merge
+							? `${RuntimeGlobals.onChunksLoaded}();`
+							: `${RuntimeGlobals.exports} = ${RuntimeGlobals.onChunksLoaded}(${RuntimeGlobals.exports});`
 					);
 				}
 				buf2.push(...renderAwaitedEntries(awaitedEntries));
+				result.exportsAwaited = awaitedEntries.includes(RuntimeGlobals.exports);
+				// Every entry has run by now, and the getters below read through to
+				// whichever one provides each name.
+				if (merge) {
+					const { exports, namespace } = getMergedExports(
+						/** @type {Module[]} */ (mergedModules),
+						moduleGraph,
+						chunk.runtime
+					);
+					buf2.push(
+						`${runtimeTemplate.renderLet()} ${RuntimeGlobals.exports} = {};`
+					);
+					if (namespace) {
+						buf2.push(
+							`${RuntimeGlobals.makeNamespaceObject}(${RuntimeGlobals.exports});`
+						);
+					}
+					if (exports.length > 0) {
+						const bindings = exports.map(
+							({ name, module, usedName }) =>
+								`${JSON.stringify(name)}, ${runtimeTemplate.returningFunction(
+									`${mergedTargets.get(module)}${propertyAccess([usedName])}`
+								)}`
+						);
+						buf2.push(
+							`${RuntimeGlobals.definePropertyGetters}(${
+								RuntimeGlobals.exports
+							}, [${bindings.join(", ")}]);`
+						);
+					}
+				}
 				if (
 					runtimeRequirements.has(RuntimeGlobals.startup) ||
 					(runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore) &&
@@ -2012,11 +2182,9 @@ class JavascriptModulesPlugin {
 		const needModuleDefer = runtimeRequirements.has(
 			RuntimeGlobals.makeDeferredNamespaceObject
 		);
-		// Both deferred-namespace runtimes re-invoke `__webpack_require__` on
-		// access, so a module's evaluation error must be retained and re-thrown
-		// (a Cyclic Module Record's [[EvaluationError]]); the optimized variant
-		// does not use `__webpack_module_deferred_exports__`, so it is tracked
-		// separately from `needModuleDefer`.
+		// Both deferred-namespace runtimes re-invoke `__webpack_require__` on access,
+		// so an evaluation error must be retained and re-thrown. The optimized one
+		// skips the deferred exports object, hence the separate flag.
 		const needModuleDeferAny =
 			needModuleDefer ||
 			runtimeRequirements.has(
@@ -2127,7 +2295,7 @@ class JavascriptModulesPlugin {
 	 * @param {CompilationHooks} hooks hooks
 	 * @param {boolean | undefined} allStrict allStrict
 	 * @param {boolean} hasChunkModules hasChunkModules
-	 * @returns {Map<Module, Source> | false} renamed inlined modules
+	 * @returns {RenamedInlinedModules | false} renamed inlined modules
 	 */
 	_getRenamedInlineModule(
 		compilation,
@@ -2144,28 +2312,31 @@ class JavascriptModulesPlugin {
 			allModules.every((m) => /** @type {BuildInfo} */ (m.buildInfo).strict);
 		const isMultipleEntries = inlinedModules.size > 1;
 		const singleEntryWithModules = inlinedModules.size === 1 && hasChunkModules;
-		// This step is before the IIFE reason calculation; it only runs for the
-		// cases whose IIFE reason it can remove: multiple inlined entry modules, or a
-		// single inlined entry alongside other chunk modules. The remaining reason
-		// ('it uses a non-standard name for the exports') is not handled here.
+		// Runs before the IIFE reason is calculated, and only for the cases whose
+		// reason it can remove: several inlined entries, or one beside other chunk
+		// modules. A non-standard exports name is not handled here.
 		if (innerStrict || (!isMultipleEntries && !singleEntryWithModules)) {
 			return false;
 		}
 
 		/** @type {Map<Module, Source>} */
 		const renamedInlinedModules = new Map();
+		/** @type {Map<Module, Map<string, string>>} */
+		const renamedDeclarations = new Map();
 		const { runtimeTemplate } = renderContext;
 
-		/** @typedef {{ source: Source, module: Module, ast: Program, variables: Set<Variable>, through: Set<Reference>, usedInNonInlined: Set<Variable>, moduleScope: Scope }} Info */
+		/** @typedef {{ source: Source, module: Module, shorthandIdentifierStarts: Set<number>, variables: Set<Variable>, through: Set<Reference>, usedInNonInlined: Set<Variable>, moduleScope: Scope }} Info */
 		/** @type {Map<Module, Info>} */
 		const inlinedModulesToInfo = new Map();
 		/** @type {Set<string>} */
 		const nonInlinedModuleThroughIdentifiers = new Set();
 		/** @type {Map<Module, Source>} */
 		const inlinedModuleSources = new Map();
+		const { codeGenerationResults, chunk } = renderContext;
 
 		for (const m of allModules) {
 			const isInlinedModule = inlinedModules && inlinedModules.has(m);
+
 			const moduleSource = this.renderModule(
 				m,
 				{
@@ -2183,6 +2354,47 @@ class JavascriptModulesPlugin {
 				inlinedModuleSources.set(m, moduleSource);
 				continue;
 			}
+			// The render hooks add free names, so only the source they left behind
+			// can be analysed; keying on it lets a rebuild skip the parse.
+			let freeNames = this._renderedFreeNamesCache.get(moduleSource);
+
+			if (freeNames === undefined) {
+				const code = /** @type {string} */ (moduleSource.source());
+
+				const { experiments } = compilation.options;
+				const { ast } = JavascriptParser._parse(
+					code,
+					{
+						sourceType: "auto",
+						ranges: true,
+						// generated code contains phase imports when the experiments are on
+						importPhases: Boolean(
+							experiments.deferImport || experiments.sourceImport
+						)
+					},
+					JavascriptParser._getModuleParseFunction(compilation, m)
+				);
+
+				const analysis = analyzeScope(ast);
+
+				freeNames = new Set();
+				for (const ref of analysis.unresolvedReferences) {
+					freeNames.add(ref.identifier.name);
+				}
+				this._renderedFreeNamesCache.set(moduleSource, freeNames);
+			}
+
+			for (const name of freeNames) {
+				nonInlinedModuleThroughIdentifiers.add(name);
+			}
+		}
+
+		/**
+		 * @param {Module} module the inlined entry
+		 * @param {Source} moduleSource its rendered source
+		 * @returns {Info} scope information for renaming
+		 */
+		const getModuleInfo = (module, moduleSource) => {
 			const code = /** @type {string} */ (moduleSource.source());
 
 			const { experiments } = compilation.options;
@@ -2196,37 +2408,71 @@ class JavascriptModulesPlugin {
 						experiments.deferImport || experiments.sourceImport
 					)
 				},
-				JavascriptParser._getModuleParseFunction(compilation, m)
+				JavascriptParser._getModuleParseFunction(compilation, module)
 			);
 
 			const analysis = analyzeScope(ast);
 
-			for (const ref of analysis.unresolvedReferences) {
-				nonInlinedModuleThroughIdentifiers.add(ref.identifier.name);
+			const moduleScope = analysis.moduleScope;
+			return {
+				source: moduleSource,
+				shorthandIdentifierStarts: analysis.shorthandIdentifierStarts,
+				module,
+				variables: new Set(moduleScope.variables),
+				through: new Set(analysis.unresolvedReferences),
+				usedInNonInlined: new Set(),
+				moduleScope
+			};
+		};
+
+		/**
+		 * @param {Info} info scope information for the entry
+		 * @param {Set<string>} usedNames names unavailable to its declarations
+		 * @returns {void}
+		 */
+		const renameModule = (info, usedNames) => {
+			const source = new ReplaceSource(info.source);
+			/** @type {Map<string, string>} */
+			const renamed = new Map();
+			for (const variable of info.variables) {
+				renameInlinedModuleVariable(
+					source,
+					info.shorthandIdentifierStarts,
+					variable,
+					info.module.identifier(),
+					info.module.readableIdentifier(runtimeTemplate.requestShortener),
+					usedNames,
+					renamed
+				);
 			}
-		}
+			renamedInlinedModules.set(info.module, source);
+			if (renamed.size > 0) renamedDeclarations.set(info.module, renamed);
+		};
 
-		// Fast path: codegen reports each inlined entry's rendered top-level
-		// declarations and free names (post-concatenation), so when no declaration
-		// collides with a free name of any other module, another entry's
-		// declarations, or a reserved name, no renaming is needed and the entries
-		// don't have to be parsed at all.
+		// Codegen reports declarations and free names; only entries whose names
+		// collide need parsing to locate their declarations and references.
 		fastPath: {
-			const { codeGenerationResults, chunk } = renderContext;
 			/** @type {Set<string>} */
 			const usedNames = new Set(nonInlinedModuleThroughIdentifiers);
 			for (const name of RESERVED_NAMES) usedNames.add(name);
-			/** @type {Set<string>[]} */
-			const declarationsList = [];
-			for (const m of inlinedModuleSources.keys()) {
+			/** @type {Map<Module, Set<string>>} */
+			const declarationsByModule = new Map();
+			let canRenameSelectively = isMultipleEntries;
+			for (const [m, moduleSource] of inlinedModuleSources) {
 				if (!codeGenerationResults.has(m, chunk.runtime)) break fastPath;
 				const result = codeGenerationResults.get(m, chunk.runtime);
 				const data = result.data;
 				if (!data) break fastPath;
 				const declarations = data.get("topLevelDeclarations");
 				if (!declarations) break fastPath;
-				declarationsList.push(declarations);
+				declarationsByModule.set(m, declarations);
 				if (!isMultipleEntries) continue;
+				// Mixing cached names with fresh scope analysis requires unchanged
+				// sources and the same parser that produced the cached names.
+				canRenameSelectively =
+					canRenameSelectively &&
+					result.sources.get(JAVASCRIPT_TYPE) === moduleSource &&
+					!JavascriptParser._getModuleParseFunction(compilation, m);
 				// Entries share the startup scope: an entry's free names and runtime
 				// globals must not be shadowed by another entry's declarations.
 				const freeNames = data.get("freeNames");
@@ -2239,49 +2485,26 @@ class JavascriptModulesPlugin {
 					}
 				}
 			}
-			for (const declarations of declarationsList) {
-				for (const name of declarations) {
-					if (usedNames.has(name)) break fastPath;
+			for (const [m, declarations] of declarationsByModule) {
+				const moduleSource = /** @type {Source} */ (
+					inlinedModuleSources.get(m)
+				);
+				if (someInIterable(declarations, (name) => usedNames.has(name))) {
+					if (!canRenameSelectively) break fastPath;
+					renameModule(getModuleInfo(m, moduleSource), usedNames);
+				} else {
+					for (const name of declarations) usedNames.add(name);
+					renamedInlinedModules.set(m, moduleSource);
 				}
-				// earlier entries' declarations join the used set so later entries
-				// are checked against them
-				for (const name of declarations) usedNames.add(name);
 			}
-			for (const [m, moduleSource] of inlinedModuleSources) {
-				renamedInlinedModules.set(m, moduleSource);
-			}
-			return renamedInlinedModules;
+			return {
+				sources: renamedInlinedModules,
+				renamedDeclarations
+			};
 		}
 
 		for (const [m, moduleSource] of inlinedModuleSources) {
-			const code = /** @type {string} */ (moduleSource.source());
-
-			const { experiments } = compilation.options;
-			const { ast } = JavascriptParser._parse(
-				code,
-				{
-					sourceType: "auto",
-					ranges: true,
-					// generated code contains phase imports when the experiments are on
-					importPhases: Boolean(
-						experiments.deferImport || experiments.sourceImport
-					)
-				},
-				JavascriptParser._getModuleParseFunction(compilation, m)
-			);
-
-			const analysis = analyzeScope(ast);
-
-			const moduleScope = analysis.moduleScope;
-			inlinedModulesToInfo.set(m, {
-				source: moduleSource,
-				ast,
-				module: m,
-				variables: new Set(moduleScope.variables),
-				through: new Set(analysis.unresolvedReferences),
-				usedInNonInlined: new Set(),
-				moduleScope
-			});
+			inlinedModulesToInfo.set(m, getModuleInfo(m, moduleSource));
 		}
 
 		for (const [, { variables, usedInNonInlined }] of inlinedModulesToInfo) {
@@ -2295,11 +2518,9 @@ class JavascriptModulesPlugin {
 			}
 		}
 
-		// Multiple inlined entry modules share the chunk's startup scope. Rename any
-		// top-level declaration that would collide with another inlined module's
-		// declaration, with any inlined or non-inlined module's free (global)
-		// reference, or with a reserved name, so the modules can be emitted without a
-		// per-entry IIFE.
+		// Several inlined entries share the chunk's startup scope, so any top-level
+		// declaration colliding with another's declaration, any module's free
+		// reference or a reserved name is renamed, sparing them a per-entry IIFE.
 		if (isMultipleEntries) {
 			/** @type {Set<string>} */
 			const allUsedNames = new Set(nonInlinedModuleThroughIdentifiers);
@@ -2307,56 +2528,37 @@ class JavascriptModulesPlugin {
 			for (const { through } of inlinedModulesToInfo.values()) {
 				for (const ref of through) allUsedNames.add(ref.identifier.name);
 			}
-			for (const [m, moduleInfo] of inlinedModulesToInfo) {
-				const { ast, source: _source } = moduleInfo;
-				const source = new ReplaceSource(_source);
-				for (const variable of moduleInfo.variables) {
-					renameInlinedModuleVariable(
-						source,
-						ast,
-						variable,
-						moduleInfo.module.identifier(),
-						m.readableIdentifier(runtimeTemplate.requestShortener),
-						allUsedNames
-					);
-				}
-				renamedInlinedModules.set(m, source);
+			for (const moduleInfo of inlinedModulesToInfo.values()) {
+				renameModule(moduleInfo, allUsedNames);
 			}
-			return renamedInlinedModules;
+			return {
+				sources: renamedInlinedModules,
+				renamedDeclarations
+			};
 		}
 
 		for (const [m, moduleInfo] of inlinedModulesToInfo) {
-			const { ast, source: _source, usedInNonInlined } = moduleInfo;
-			const source = new ReplaceSource(_source);
+			const { usedInNonInlined } = moduleInfo;
 			if (usedInNonInlined.size === 0) {
-				renamedInlinedModules.set(m, source);
+				renamedInlinedModules.set(m, new ReplaceSource(moduleInfo.source));
 				continue;
 			}
 
-			const info = /** @type {Info} */ (inlinedModulesToInfo.get(m));
 			const allUsedNames = new Set(
-				Array.from(info.through, (v) => v.identifier.name)
+				Array.from(moduleInfo.through, (v) => v.identifier.name)
 			);
 
 			for (const variable of usedInNonInlined) {
 				allUsedNames.add(variable.name);
 			}
 
-			for (const variable of info.variables) {
-				renameInlinedModuleVariable(
-					source,
-					ast,
-					variable,
-					info.module.identifier(),
-					m.readableIdentifier(runtimeTemplate.requestShortener),
-					allUsedNames
-				);
-			}
-
-			renamedInlinedModules.set(m, source);
+			renameModule(moduleInfo, allUsedNames);
 		}
 
-		return renamedInlinedModules;
+		return {
+			sources: renamedInlinedModules,
+			renamedDeclarations
+		};
 	}
 }