webpack 5.111.0 → 5.112.0

package/lib/library/ModuleLibraryPlugin.js

@@ -6,27 +6,30 @@
 "use strict";
 
 const { ConcatSource } = require("webpack-sources");
-const { UsageState } = require("../ExportsInfo");
-const ExternalModule = require("../ExternalModule");
-const { JAVASCRIPT_TYPE } = require("../ModuleSourceTypeConstants");
-const RuntimeGlobals = require("../RuntimeGlobals");
-const Template = require("../Template");
-const HarmonyExportExpressionDependency = require("../dependencies/HarmonyExportExpressionDependency");
-const HarmonyExportImportedSpecifierDependency = require("../dependencies/HarmonyExportImportedSpecifierDependency");
-const HarmonyExportSpecifierDependency = require("../dependencies/HarmonyExportSpecifierDependency");
 const ExternalStarReexportError = require("../errors/ExternalStarReexportError");
+const { UsageState } = require("../graph/ExportsInfo");
+const isDependencyKind = require("../graph/isDependencyKind");
 const JavascriptModulesPlugin = require("../javascript/JavascriptModulesPlugin");
-const ConcatenatedModule = require("../optimize/ConcatenatedModule");
-const { InlinedUsedName } = require("../optimize/InlineExports");
-const { toJsStringLiteral } = require("../util/identifier");
+const {
+	getMergedExports,
+	mergedEntryModules
+} = require("../javascript/MergedEntryExports");
+const { JAVASCRIPT_TYPE } = require("../module/ModuleSourceTypeConstants");
+const { isInlinedUsedName } = require("../optimize/InlineExports");
+const RuntimeGlobals = require("../runtime/RuntimeGlobals");
+const Template = require("../template/Template");
+const { someInIterable } = require("../util/IterableHelpers");
+const { renameIdentifiers } = require("../util/concatenate");
 const {
 	RESERVED_IDENTIFIER,
 	SAFE_IDENTIFIER,
 	propertyAccess
 } = require("../util/property");
-const { getEntryRuntime, getRuntimeKey } = require("../util/runtime");
+const { getEntryRuntime, intersectRuntime } = require("../util/runtime");
 const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 
+/** @import ExternalModule from "../externals/ExternalModule" */
+/** @import { InlinedUsedName } from "../optimize/InlineExports" */
 /** @import { Source } from "webpack-sources" */
 /**
  * @import {
@@ -35,18 +38,17 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
  * 	LibraryExport
  * } from "../../declarations/WebpackOptions"
  */
-/** @import Chunk from "../Chunk" */
+/** @import CodeGenerationResults from "../module/CodeGenerationResults" */
 /** @import Compilation from "../Compilation" */
 /** @import Compiler from "../Compiler" */
-/** @import ModuleGraph from "../ModuleGraph" */
-/** @import Module, { BuildMeta } from "../Module" */
+/** @import ModuleGraph from "../graph/ModuleGraph" */
+/** @import Module from "../module/Module" */
 /**
  * @import {
  * 	StartupRenderContext,
  * 	ModuleRenderContext
  * } from "../javascript/JavascriptModulesPlugin"
  */
-/** @import { ImportAttributes } from "../javascript/JavascriptParser" */
 /** @import { RuntimeSpec } from "../util/runtime" */
 /**
  * @import {
@@ -83,37 +85,19 @@ const PLUGIN_NAME = "ModuleLibraryPlugin";
 const libraryEntryModules = new WeakMap();
 
 /**
- * Whether every export the module defines is a binding the library can export
- * natively, so the definitions written into the exports object are read by nobody.
- * A re-export or a renamed import is not: `renderStartup` reads those back off the
- * object, and `treatAsCommonJs` hands the object out as the default export.
+ * Whether the library reads every export of the entry off its exports object, never
+ * binding one to a declaration of the inlined body, so no definition can be left out.
  * @param {Module} module the entry module
  * @param {ModuleGraph} moduleGraph the module graph
- * @returns {boolean} true when the definitions may be taken over
+ * @returns {boolean} true when the entry has no export the library exposes natively
  */
-const definesOnlyNativeExports = (module, moduleGraph) => {
+const noNativeExports = (module, moduleGraph) => {
 	const buildMeta = /** @type {JavascriptModuleBuildMeta} */ (module.buildMeta);
-	if (buildMeta && buildMeta.treatAsCommonJs) return false;
+	if (buildMeta && buildMeta.treatAsCommonJs) return true;
 	// A top-level `await` wraps the body in `__webpack_require__.a`, and the
 	// definitions read declarations inside that wrapper — re-emitting them after the
 	// module would put them out of scope.
-	if (moduleGraph.isAsync(module)) return false;
-	const topLevelDeclarations =
-		module.buildInfo && module.buildInfo.topLevelDeclarations;
-	if (!topLevelDeclarations) return false;
-	for (const dep of module.dependencies) {
-		// A re-export or an `export default` has no declaration of its own to bind to,
-		// so `renderStartup` reads its value back off the exports object.
-		if (
-			dep instanceof HarmonyExportImportedSpecifierDependency ||
-			dep instanceof HarmonyExportExpressionDependency
-		) {
-			return false;
-		}
-		if (!(dep instanceof HarmonyExportSpecifierDependency)) continue;
-		if (!topLevelDeclarations.has(dep.id)) return false;
-	}
-	return true;
+	return moduleGraph.isAsync(module);
 };
 
 /**
@@ -125,18 +109,6 @@ const definesOnlyNativeExports = (module, moduleGraph) => {
 const toExportName = (name) =>
 	SAFE_IDENTIFIER.test(name) ? name : JSON.stringify(name);
 
-/**
- * Renders the import attributes of a reexport in the syntax the author wrote,
- * since a legacy `assert` clause and a `with` clause are not interchangeable.
- * @param {ImportAttributes | undefined} attributes the import attributes
- * @returns {string} the attributes clause, empty when there are none
- */
-const toAttributesClause = (attributes) => {
-	if (!attributes) return "";
-	const { _isLegacyAssert: isLegacyAssert, ...values } = attributes;
-	return ` ${isLegacyAssert ? "assert" : "with"} ${JSON.stringify(values)}`;
-};
-
 /**
  * Whether the export name can also be used as the declared binding name.
  * @param {string} name export name
@@ -171,76 +143,33 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		super.apply(compiler);
 
 		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
-			const { onDemandExportsGeneration } =
-				ConcatenatedModule.getCompilationHooks(compilation);
 			const javascriptHooks =
 				JavascriptModulesPlugin.getCompilationHooks(compilation);
-			onDemandExportsGeneration.tap(
-				PLUGIN_NAME,
-				(module, runtimes, source, finalName) => {
-					/** @type {BuildMeta} */
-					const buildMeta = module.buildMeta || (module.buildMeta = {});
-
-					/** @type {BuildMeta["exportsSourceByRuntime"]} */
-					const exportsSourceByRuntime =
-						buildMeta.exportsSourceByRuntime ||
-						(buildMeta.exportsSourceByRuntime = new Map());
-
-					/** @type {BuildMeta["exportsFinalNameByRuntime"]} */
-					const exportsFinalNameByRuntime =
-						buildMeta.exportsFinalNameByRuntime ||
-						(buildMeta.exportsFinalNameByRuntime = new Map());
-
-					for (const runtime of runtimes) {
-						const key = getRuntimeKey(runtime);
-						exportsSourceByRuntime.set(key, source);
-						exportsFinalNameByRuntime.set(key, finalName);
-					}
 
-					return true;
-				}
-			);
-			// The same for a plain entry, whose definitions come from a dependency template.
-			// Placed after the module body, which its value bindings read.
-			javascriptHooks.onDemandExportsGeneration.tap(
-				PLUGIN_NAME,
-				(module, runtime, source, placeAtEnd) => {
-					const entries = libraryEntryModules.get(compilation);
-					if (!entries || !entries.has(module)) return;
-					if (!definesOnlyNativeExports(module, compilation.moduleGraph)) {
-						return;
-					}
-					/** @type {BuildMeta} */
-					const buildMeta = module.buildMeta || (module.buildMeta = {});
-					const key = getRuntimeKey(runtime);
-					if (placeAtEnd) {
-						const bindings =
-							buildMeta.exportsBindingSourceByRuntime ||
-							(buildMeta.exportsBindingSourceByRuntime = new Map());
-						bindings.set(key, source);
-					} else {
-						const sources =
-							buildMeta.exportsSourceByRuntime ||
-							(buildMeta.exportsSourceByRuntime = new Map());
-						// The `__esModule` marker and the definitions both land here, so
-						// keep whichever arrived first rather than replacing it.
-						const before = sources.get(key);
-						sources.set(key, before ? `${before}${source}` : source);
+			compilation.hooks.beforeCodeGeneration.tap(PLUGIN_NAME, () => {
+				const entries = libraryEntryModules.get(compilation);
+				if (entries === undefined) return;
+				const { moduleGraph } = compilation;
+				for (const { dependencies } of compilation.entries.values()) {
+					for (const dep of dependencies) {
+						const module = dep && moduleGraph.getModule(dep);
+						if (!module) continue;
+						const root = module.getRootModule();
+						if (!entries.has(root)) continue;
+						if (root === module && noNativeExports(module, moduleGraph)) {
+							continue;
+						}
+						moduleGraph.getMeta(module).onDemandExports = true;
 					}
-					return true;
 				}
-			);
+			});
 
-			// `ModuleLibraryPlugin` stashes the on-demand exports source via
-			// `onDemandExportsGeneration` and only re-emits it when the
-			// module is wrapped in an IIFE/factory. When the entry is
-			// inlined directly, the stashed source — and the
-			// `definePropertyGetters` / `requireScope` runtime helpers it
-			// pulled in — never make it into the output. Drop those helpers
-			// from the chunk's set so the bundle stays clean.
+			// The stashed exports source is re-emitted only where the entry is wrapped;
+			// inlined directly, the helpers it pulled in have no reader and can go.
 			compilation.hooks.additionalChunkRuntimeRequirements.tap(
 				PLUGIN_NAME,
 				(chunk, set, { chunkGraph, codeGenerationResults }) => {
+					const { moduleGraph, runtimeTemplate } = compilation;
 					if (!set.has(RuntimeGlobals.definePropertyGetters)) return;
 					if (chunkGraph.getNumberOfEntryModules(chunk) !== 1) return;
 					if (
@@ -255,22 +184,58 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 					if (javascriptHooks.inlineInRuntimeBailout.isUsed()) return;
 
 					const [module] = chunkGraph.getChunkEntryModulesIterable(chunk);
-					const runtimeKey = getRuntimeKey(chunk.runtime);
-					const buildMeta = module.buildMeta;
-					const takenOver =
-						(buildMeta &&
-							buildMeta.exportsSourceByRuntime &&
-							buildMeta.exportsSourceByRuntime.has(runtimeKey)) ||
-						(buildMeta &&
-							buildMeta.exportsBindingSourceByRuntime &&
-							buildMeta.exportsBindingSourceByRuntime.has(runtimeKey));
-					if (!takenOver) return;
+					if (chunk.hasRuntime()) {
+						// The startup inlines the entry only where nothing else loads with
+						// it: another chunk of the entrypoint delays the execution, and a
+						// module reading the entry needs it in the registry.
+						for (const [
+							,
+							entrypoint
+						] of chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)) {
+							if (entrypoint && entrypoint.chunks.some((c) => c !== chunk)) {
+								return;
+							}
+						}
+						if (
+							someInIterable(
+								moduleGraph.getIncomingConnectionsByOriginModule(module),
+								([originModule, connections]) =>
+									originModule &&
+									originModule !== module &&
+									connections.some((c) => c.isTargetActive(chunk.runtime)) &&
+									someInIterable(
+										chunkGraph.getModuleRuntimes(originModule),
+										(runtime) =>
+											intersectRuntime(runtime, chunk.runtime) !== undefined
+									)
+							)
+						) {
+							return;
+						}
+					} else if (
+						// A chunk whose runtime is elsewhere lifts its entry to the top
+						// level under the same conditions, and renders it into the module
+						// registry otherwise.
+						JavascriptModulesPlugin._getEsmEntryModuleToInline({
+							chunk,
+							chunkGraph,
+							moduleGraph,
+							runtimeTemplate,
+							codeGenerationResults
+						}) !== module
+					) {
+						return;
+					}
 					const codeGenResult = codeGenerationResults.get(
 						module,
 						chunk.runtime
 					);
-					const jsSource =
-						codeGenResult && codeGenResult.sources.get("javascript");
+					const { data } = codeGenResult;
+					const takenOver =
+						data !== undefined &&
+						(data.has("exportsSource") || data.has("exportsBindingSource"));
+					if (!takenOver) return;
+					const jsSource = codeGenResult.sources.get("javascript");
 					if (
 						jsSource &&
 						String(jsSource.source()).includes(`${RuntimeGlobals.require}.`)
@@ -289,45 +254,32 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 						}
 					}
 
-					// The helpers land in the runtime, not in this chunk, so what still
-					// needs them is asked of every chunk sharing the entrypoint — the
-					// runtime chunk, and whatever `splitChunks` moved out of the entry.
-					/** @type {Set<Chunk>} */
-					const siblings = new Set([chunk]);
-					for (const [
-						,
-						entrypoint
-					] of chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)) {
-						if (!entrypoint) continue;
-						for (const sibling of entrypoint.chunks) siblings.add(sibling);
-					}
-
+					// The entrypoint loads as this chunk alone, so what still needs the
+					// helpers is whatever else it holds beside the entry.
 					let otherNeedsDefine = false;
 					let otherNeedsNamespaceObject = false;
 					let otherNeedsExports = false;
 					let otherNeedsRequireScope = false;
-					outer: for (const sibling of siblings) {
-						for (const m of chunkGraph.getChunkModulesIterable(sibling)) {
-							if (m === module) continue;
-							const requirements = chunkGraph.getModuleRuntimeRequirements(
-								m,
-								sibling.runtime
-							);
-							if (!requirements) continue;
-							if (requirements.has(RuntimeGlobals.definePropertyGetters)) {
-								otherNeedsDefine = true;
-							}
-							if (requirements.has(RuntimeGlobals.makeNamespaceObject)) {
-								otherNeedsNamespaceObject = true;
-							}
-							if (requirements.has(RuntimeGlobals.exports)) {
-								otherNeedsExports = true;
-							}
-							if (requirements.has(RuntimeGlobals.requireScope)) {
-								otherNeedsRequireScope = true;
-							}
-							if (otherNeedsDefine) break outer;
+					for (const m of chunkGraph.getChunkModulesIterable(chunk)) {
+						if (m === module) continue;
+						const requirements = chunkGraph.getModuleRuntimeRequirements(
+							m,
+							chunk.runtime
+						);
+						if (!requirements) continue;
+						if (requirements.has(RuntimeGlobals.definePropertyGetters)) {
+							otherNeedsDefine = true;
+						}
+						if (requirements.has(RuntimeGlobals.makeNamespaceObject)) {
+							otherNeedsNamespaceObject = true;
+						}
+						if (requirements.has(RuntimeGlobals.exports)) {
+							otherNeedsExports = true;
+						}
+						if (requirements.has(RuntimeGlobals.requireScope)) {
+							otherNeedsRequireScope = true;
 						}
+						if (otherNeedsDefine) break;
 					}
 
 					if (otherNeedsDefine) return;
@@ -414,7 +366,8 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 
 				// Only handle star-reexport statement
 				if (
-					!(dep instanceof HarmonyExportImportedSpecifierDependency) ||
+					dep === null ||
+					!isDependencyKind(dep, "esm-reexport") ||
 					dep.name !== null
 				) {
 					continue;
@@ -428,7 +381,7 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 				) {
 					continue;
 				}
-				if (importedModule instanceof ExternalModule) {
+				if (importedModule.is("external")) {
 					const request = importedModule.getResolvedRequest();
 					if (Array.isArray(request) && request.length > 1) {
 						unsupportedExternals.add(importedModule);
@@ -472,6 +425,7 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 	 * @param {Module} module module
 	 * @param {ModuleGraph} moduleGraph moduleGraph
 	 * @param {RuntimeSpec} runtime chunk runtime
+	 * @param {CodeGenerationResults} codeGenerationResults the code generation results
 	 * @param {[string, string][]} exports exports
 	 * @param {Set<string>} alreadyRenderedExports already rendered exports
 	 * @returns {ConcatSource} source with null provided exports
@@ -481,6 +435,7 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		module,
 		moduleGraph,
 		runtime,
+		codeGenerationResults,
 		exports,
 		alreadyRenderedExports
 	) {
@@ -504,7 +459,8 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 
 				// Only handle star-reexport statement
 				if (
-					dep instanceof HarmonyExportImportedSpecifierDependency &&
+					dep !== null &&
+					isDependencyKind(dep, "esm-reexport") &&
 					dep.name === null
 				) {
 					const importedModule = connection.resolvedModule;
@@ -518,21 +474,15 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 						importedModuleExportsInfo._otherExportsInfo.provided === null
 					) {
 						// Handle export * from 'external'
-						if (importedModule instanceof ExternalModule) {
-							const request = importedModule.getResolvedRequest();
-							// A property path is reported by `_checkStarReexportedExternals`,
-							// and an absent one by the external's own build
-							const specifier =
-								typeof request === "string"
-									? request
-									: Array.isArray(request) && request.length === 1
-										? request[0]
-										: undefined;
-							if (specifier !== undefined) {
-								externalReexports.add(
-									`export * from ${toJsStringLiteral(specifier)}${toAttributesClause(dep.attributes)};\n`
-								);
-							}
+						if (importedModule.is("external")) {
+							const from = codeGenerationResults.has(importedModule, runtime)
+								? codeGenerationResults.getData(
+										importedModule,
+										runtime,
+										"externalReexport"
+									)
+								: undefined;
+							if (from) externalReexports.add(`export * ${from};\n`);
 						} else if (!visitedReexportModules.has(importedModule)) {
 							visitedReexportModules.add(importedModule);
 							resolveDynamicStarReexport(importedModule, true);
@@ -568,7 +518,7 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		for (const [origin, used] of unknownProvidedExports) {
 			exports.push([
 				origin,
-				used instanceof InlinedUsedName
+				isInlinedUsedName(used)
 					? used.render(
 							Template.toNormalComment(
 								`inlined export ${propertyAccess([origin])}`
@@ -593,12 +543,18 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		const {
 			moduleGraph,
 			chunk,
+			chunkGraph,
 			codeGenerationResults,
 			inlined,
 			inlinedInIIFE,
+			exportsAwaited,
 			runtimeTemplate
 		} = renderContext;
 		let result = new ConcatSource(source);
+		// A merged entry exposes what its modules expose together, so the ESM
+		// export list is theirs rather than the last module's alone.
+		const mergedModules = mergedEntryModules(chunk, chunkGraph, compilation);
+		const exportedModules = mergedModules || [module];
 		const exportInfos = options.export
 			? [
 					moduleGraph.getExportInfo(
@@ -606,21 +562,36 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 						Array.isArray(options.export) ? options.export[0] : options.export
 					)
 				]
-			: moduleGraph.getExportsInfo(module).orderedExports;
+			: mergedModules
+				? getMergedExports(
+						mergedModules,
+						moduleGraph,
+						chunk.runtime
+					).exports.map(({ name, module: from }) =>
+						moduleGraph.getExportInfo(from, name)
+					)
+				: moduleGraph.getExportsInfo(module).orderedExports;
 
-		const exportsFinalNameByRuntime =
-			(module.buildMeta &&
-				module.buildMeta.exportsFinalNameByRuntime &&
-				module.buildMeta.exportsFinalNameByRuntime.get(
-					getRuntimeKey(chunk.runtime)
-				)) ||
-			{};
+		const { data } = codeGenerationResults.get(module, chunk.runtime);
 
 		const isInlinedEntryWithoutIIFE = inlined && !inlinedInIIFE;
-		// Direct export bindings from on-demand concatenation
-		const definitions = isInlinedEntryWithoutIIFE
-			? exportsFinalNameByRuntime
-			: {};
+		// The binding each export left out on demand reads, exported directly
+		/** @type {Record<string, string>} */
+		let definitions =
+			(isInlinedEntryWithoutIIFE && data && data.get("exportsFinalName")) || {};
+		// Inlined beside other modules, the entry's colliding declarations were renamed
+		const { renamedDeclarations } = renderContext;
+		if (renamedDeclarations) {
+			/** @type {Record<string, string>} */
+			const renamed = {};
+			for (const usedName of Object.keys(definitions)) {
+				renamed[usedName] = renameIdentifiers(
+					definitions[usedName],
+					renamedDeclarations
+				);
+			}
+			definitions = renamed;
+		}
 
 		/** @type {string[]} */
 		const shortHandedExports = [];
@@ -646,48 +617,15 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 			return name;
 		};
 
-		const isAsync = moduleGraph.isAsync(module);
-
-		const treatAsCommonJs =
-			module.buildMeta &&
-			/** @type {JavascriptModuleBuildMeta} */ (module.buildMeta)
-				.treatAsCommonJs;
-		const skipRenderDefaultExport = Boolean(treatAsCommonJs);
-
-		// A single (non-concatenated) inlined entry is rendered at the top
-		// level, so its own declarations are top-level bindings we can export
-		// directly — keeping ESM live bindings instead of snapshotting
-		// `__webpack_exports__.x` into a `const`. Concatenated entries already
-		// get direct bindings via `definitions` above.
-		/** @type {Map<string, string> | undefined} */
-		let directBindings;
-		if (isInlinedEntryWithoutIIFE && !treatAsCommonJs) {
-			const { data } = codeGenerationResults.get(module, chunk.runtime);
-			const topLevelDeclarations =
-				(data && data.get("topLevelDeclarations")) ||
-				(module.buildInfo && module.buildInfo.topLevelDeclarations);
-			if (topLevelDeclarations) {
-				for (const dep of module.dependencies) {
-					if (
-						dep instanceof HarmonyExportSpecifierDependency &&
-						topLevelDeclarations.has(dep.id)
-					) {
-						(directBindings || (directBindings = new Map())).set(
-							dep.name,
-							dep.id
-						);
-					}
-				}
-			}
-		}
+		// A merged entry is awaited in the bootstrap, so the object here is settled.
+		const isAsync = !mergedModules && moduleGraph.isAsync(module);
 
-		// Taken over by `onDemandExportsGeneration` above, and re-emitted by
-		// `renderModuleContent` only where the module is wrapped — which is not here.
-		const bindingsTakenOver = Boolean(
-			module.buildMeta &&
-			module.buildMeta.exportsBindingSourceByRuntime &&
-			module.buildMeta.exportsBindingSourceByRuntime.has(
-				getRuntimeKey(chunk.runtime)
+		// One ES module among the merged ones still provides a real `default`, and
+		// the synthetic one below would then be a second export of that name.
+		const treatAsCommonJs = exportedModules.every((m) =>
+			Boolean(
+				m.buildMeta &&
+				/** @type {JavascriptModuleBuildMeta} */ (m.buildMeta).treatAsCommonJs
 			)
 		);
 
@@ -704,83 +642,73 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		let needExportsDeclaration =
 			!isInlinedEntryWithoutIIFE || isAsync || needHarmonyCompatibilityFlag;
 
-		if (isAsync) {
+		// The startup awaits the entry wherever top-level `await` reaches it.
+		if (isAsync && !exportsAwaited) {
 			result.add(
 				`${RuntimeGlobals.exports} = await ${RuntimeGlobals.exports};\n`
 			);
 		}
 
 		// Try to find all known exports of the entry module
-		outer: for (const exportInfo of exportInfos) {
+		for (const exportInfo of exportInfos) {
 			if (!exportInfo.provided) continue;
 
 			const originalName = exportInfo.name;
 			// Skip rendering the default export in some cases
-			if (skipRenderDefaultExport && originalName === "default") continue;
+			if (treatAsCommonJs && originalName === "default") continue;
 
 			// Try to find all exports from the reexported modules
-			const target = exportInfo.findTarget(moduleGraph, (_m) => true);
-			// A namespace object target (`export * as ns from "./module"`) has no
-			// export name, so there is nothing that could be missing
-			if (target && target.export) {
-				const targetExport = target.export[0];
-				const reexportsInfo = moduleGraph.getExportsInfo(target.module);
-				for (const reexportInfo of reexportsInfo.orderedExports) {
-					if (
-						reexportInfo.provided === false &&
-						reexportInfo.name !== "default" &&
-						reexportInfo.name === targetExport
-					) {
-						continue outer;
-					}
-				}
+			const target = exportInfo.getTarget(moduleGraph);
+
+			// A re-export is provided even when its target lacks the export, and
+			// the path can end in a property access, so every name is looked up.
+			if (
+				target &&
+				target.export &&
+				target.export[target.export.length - 1] !== "default" &&
+				moduleGraph
+					.getExportsInfo(target.module)
+					.isExportProvided(target.export) === false
+			) {
+				continue;
 			}
 
-			const externalTarget = exportInfo.getTarget(moduleGraph);
 			if (
-				externalTarget &&
-				externalTarget.module instanceof ExternalModule &&
-				externalTarget.export &&
-				externalTarget.export.length === 1 &&
-				codeGenerationResults.has(externalTarget.module, chunk.runtime)
+				target &&
+				target.module.is("external") &&
+				target.export &&
+				target.export.length === 1 &&
+				codeGenerationResults.has(target.module, chunk.runtime)
 			) {
 				const reexport = codeGenerationResults.getData(
-					externalTarget.module,
+					target.module,
 					chunk.runtime,
 					"externalReexport"
 				);
 				if (reexport) {
-					if (!bindingsTakenOver) needExportsDeclaration = true;
+					// The getter stays in the body, written into the object
+					needExportsDeclaration = true;
 					result.add(
-						`export { ${toExportName(externalTarget.export[0])} as ${toExportName(originalName)} } ${reexport};\n`
+						`export { ${toExportName(target.export[0])} as ${toExportName(originalName)} } ${reexport};\n`
 					);
 					alreadyRenderedExports.add(originalName);
 					continue;
 				}
 			}
 
-			// The exports of entry module are never inlined
-			const usedName =
-				/** @type {string} */
-				(exportInfo.getUsedName(originalName, chunk.runtime));
+			// The exports of entry module are never inlined, and a merged exports
+			// object is keyed by the original names rather than the mangled ones.
+			const usedName = mergedModules
+				? originalName
+				: /** @type {string} */
+					(exportInfo.getUsedName(originalName, chunk.runtime));
 			/** @type {string | undefined} */
 			const definition = definitions[usedName];
 			/** @type {string | undefined} */
-			const directLocal =
-				definition === undefined && directBindings
-					? directBindings.get(originalName)
-					: undefined;
-			/** @type {string | undefined} */
 			let finalName;
 
 			if (definition) {
 				finalName = definition;
-			} else if (directLocal !== undefined) {
-				// Live binding to the inlined entry's own top-level declaration
-				finalName = directLocal;
-				// The declaration is only there for the definitions written into it; with
-				// those taken over (and not re-emitted here) nothing reads the object.
-				if (!bindingsTakenOver) needExportsDeclaration = true;
 			} else {
 				// Fallback to `__webpack_exports__` property access
 				// when no direct export binding was found
@@ -801,7 +729,6 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 					finalName.includes("("))
 			) {
 				if (exportInfo.isReexport()) {
-					const { data } = codeGenerationResults.get(module, chunk.runtime);
 					const topLevelDeclarations =
 						(data && data.get("topLevelDeclarations")) ||
 						(module.buildInfo && module.buildInfo.topLevelDeclarations);
@@ -844,6 +771,7 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 			module,
 			moduleGraph,
 			chunk.runtime,
+			codeGenerationResults,
 			exports,
 			alreadyRenderedExports
 		);
@@ -880,19 +808,13 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 	renderModuleContent(
 		source,
 		module,
-		{ factory, inlinedInIIFE, chunk },
+		{ factory, inlinedInIIFE, chunk, codeGenerationResults },
 		libraryContext
 	) {
-		const runtimeKey = getRuntimeKey(chunk.runtime);
-		const buildMeta = module.buildMeta;
-		const exportsSource =
-			buildMeta &&
-			buildMeta.exportsSourceByRuntime &&
-			buildMeta.exportsSourceByRuntime.get(runtimeKey);
-		const bindingSource =
-			buildMeta &&
-			buildMeta.exportsBindingSourceByRuntime &&
-			buildMeta.exportsBindingSourceByRuntime.get(runtimeKey);
+		const { data } = codeGenerationResults.get(module, chunk.runtime);
+		if (data === undefined) return source;
+		const exportsSource = data.get("exportsSource");
+		const bindingSource = data.get("exportsBindingSource");
 
 		// Re-add the exports source in a factory or IIFE-wrapped startup module; value
 		// bindings read the declarations above them, so those go after the body.