webpack/lib/library/ModuleLibraryPlugin.js

Packs ECMAScript/CommonJs/AMD modules for the browser. Allows you to split your codebase into multiple bundles, which can be loaded on demand. Supports loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.

/*
	MIT License http://www.opensource.org/licenses/mit-license.php
	Author Tobias Koppers @sokra
*/

"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 JavascriptModulesPlugin = require("../javascript/JavascriptModulesPlugin");
const ConcatenatedModule = require("../optimize/ConcatenatedModule");
const { InlinedUsedName } = require("../optimize/InlineExports");
const {
	RESERVED_IDENTIFIER,
	SAFE_IDENTIFIER,
	propertyAccess
} = require("../util/property");
const { getEntryRuntime, getRuntimeKey } = require("../util/runtime");
const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");

/** @import { Source } from "webpack-sources" */
/**
 * @import {
 * 	LibraryOptions,
 * 	LibraryType,
 * 	LibraryExport
 * } from "../../declarations/WebpackOptions"
 */
/** @import Chunk from "../Chunk" */
/** @import Compilation from "../Compilation" */
/** @import Compiler from "../Compiler" */
/** @import ModuleGraph from "../ModuleGraph" */
/** @import Module, { BuildMeta } from "../Module" */
/**
 * @import {
 * 	StartupRenderContext,
 * 	ModuleRenderContext
 * } from "../javascript/JavascriptModulesPlugin"
 */
/** @import { RuntimeSpec } from "../util/runtime" */
/**
 * @import {
 * 	JavascriptModuleBuildMeta
 * } from "../javascript/JavascriptModule"
 */

/**
 * Defines the shared type used by this module.
 * @template T
 * @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T>
 */

/**
 * Defines the module library plugin options type used by this module.
 * @typedef {object} ModuleLibraryPluginOptions
 * @property {LibraryType} type
 */

/**
 * Defines the module library plugin parsed type used by this module.
 * @typedef {object} ModuleLibraryPluginParsed
 * @property {string} name
 * @property {LibraryExport=} export
 */

const PLUGIN_NAME = "ModuleLibraryPlugin";

/**
 * The entry modules this plugin renders `export { … }` for, per compilation — the
 * only ones whose export definitions may be taken over.
 * @type {WeakMap<Compilation, WeakSet<Module>>}
 */
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.
 * @param {Module} module the entry module
 * @param {ModuleGraph} moduleGraph the module graph
 * @returns {boolean} true when the definitions may be taken over
 */
const definesOnlyNativeExports = (module, moduleGraph) => {
	const buildMeta = /** @type {JavascriptModuleBuildMeta} */ (module.buildMeta);
	if (buildMeta && buildMeta.treatAsCommonJs) return false;
	// 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;
};

/**
 * An export name is either an identifier name (reserved words included, e.g.
 * `default`) or a string literal (arbitrary module namespace names).
 * @param {string} name export name
 * @returns {string} name as it can be written after `as`
 */
const toExportName = (name) =>
	SAFE_IDENTIFIER.test(name) ? name : JSON.stringify(name);

/**
 * Whether the export name can also be used as the declared binding name.
 * @param {string} name export name
 * @returns {boolean} true, when the name can be declared
 */
const isDeclarableExportName = (name) =>
	SAFE_IDENTIFIER.test(name) && !RESERVED_IDENTIFIER.has(name);

/**
 * Represents the module library plugin runtime component.
 * @typedef {ModuleLibraryPluginParsed} T
 * @extends {AbstractLibraryPlugin<ModuleLibraryPluginParsed>}
 */
class ModuleLibraryPlugin extends AbstractLibraryPlugin {
	/**
	 * Creates an instance of ModuleLibraryPlugin.
	 * @param {ModuleLibraryPluginOptions} options the plugin options
	 */
	constructor(options) {
		super({
			pluginName: "ModuleLibraryPlugin",
			type: options.type
		});
	}

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 * @param {Compiler} compiler the compiler instance
	 * @returns {void}
	 */
	apply(compiler) {
		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);
					}
					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.
			compilation.hooks.additionalChunkRuntimeRequirements.tap(
				PLUGIN_NAME,
				(chunk, set, { chunkGraph, codeGenerationResults }) => {
					if (!set.has(RuntimeGlobals.definePropertyGetters)) return;
					if (chunkGraph.getNumberOfEntryModules(chunk) !== 1) return;
					if (
						set.has(RuntimeGlobals.moduleFactories) ||
						set.has(RuntimeGlobals.moduleCache) ||
						set.has(RuntimeGlobals.interceptModuleExecution) ||
						set.has(RuntimeGlobals.module) ||
						set.has(RuntimeGlobals.thisAsExports)
					) {
						return;
					}
					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;
					const codeGenResult = codeGenerationResults.get(
						module,
						chunk.runtime
					);
					const jsSource =
						codeGenResult && codeGenResult.sources.get("javascript");
					if (
						jsSource &&
						String(jsSource.source()).includes(`${RuntimeGlobals.require}.`)
					) {
						return;
					}

					// Without `avoidEntryIife`, another rendered module wraps the entry in
					// an IIFE, which re-emits the stashed source — its helpers stay.
					if (!compilation.options.optimization.avoidEntryIife) {
						for (const m of chunkGraph.getChunkModulesIterableBySourceType(
							chunk,
							JAVASCRIPT_TYPE
						) || []) {
							if (m !== module) return;
						}
					}

					// 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);
					}

					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;
						}
					}

					if (otherNeedsDefine) return;
					set.delete(RuntimeGlobals.definePropertyGetters);
					if (!otherNeedsNamespaceObject) {
						set.delete(RuntimeGlobals.makeNamespaceObject);
					}
					if (!otherNeedsExports) set.delete(RuntimeGlobals.exports);
					if (!otherNeedsRequireScope) set.delete(RuntimeGlobals.requireScope);
				}
			);
		});
	}

	/**
	 * Finish entry module.
	 * @param {Module} module the exporting entry module
	 * @param {string} entryName the name of the entrypoint
	 * @param {LibraryContext<T>} libraryContext context
	 * @returns {void}
	 */
	finishEntryModule(
		module,
		entryName,
		{ options, compilation, compilation: { moduleGraph } }
	) {
		const runtime = getEntryRuntime(compilation, entryName);
		if (options.export) {
			const exportsInfo = moduleGraph.getExportInfo(
				module,
				Array.isArray(options.export) ? options.export[0] : options.export
			);
			exportsInfo.setUsed(UsageState.Used, runtime);
			exportsInfo.canMangleUse = false;
			exportsInfo.canInlineUse = false;
		} else {
			const exportsInfo = moduleGraph.getExportsInfo(module);

			if (
				// If the entry module is commonjs, its exports cannot be mangled
				(module.buildMeta &&
					/** @type {JavascriptModuleBuildMeta} */ (module.buildMeta)
						.treatAsCommonJs) ||
				// The entry module provides unknown exports
				exportsInfo._otherExportsInfo.provided === null
			) {
				exportsInfo.setUsedInUnknownWay(runtime);
			} else {
				exportsInfo.setAllKnownExportsUsed(runtime);
				for (const exportInfo of exportsInfo.ownedExports) {
					exportInfo.canInlineUse = false;
				}
			}
		}
		moduleGraph.addExtraReason(module, "used as library export");
		let entries = libraryEntryModules.get(compilation);
		if (entries === undefined) {
			entries = new WeakSet();
			libraryEntryModules.set(compilation, entries);
		}
		entries.add(module);
	}

	/**
	 * Returns preprocess as needed by overriding.
	 * @param {LibraryOptions} library normalized library option
	 * @returns {T} preprocess as needed by overriding
	 */
	parseOptions(library) {
		const { name } = library;
		if (name) {
			throw new Error(
				`Library name must be unset. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
			);
		}
		const _name = /** @type {string} */ (name);
		return {
			name: _name,
			export: library.export
		};
	}

	/**
	 * Analyze unknown provided exports.
	 * @param {Source} source source
	 * @param {Module} module module
	 * @param {ModuleGraph} moduleGraph moduleGraph
	 * @param {RuntimeSpec} runtime chunk runtime
	 * @param {[string, string][]} exports exports
	 * @param {Set<string>} alreadyRenderedExports already rendered exports
	 * @returns {ConcatSource} source with null provided exports
	 */
	_analyzeUnknownProvidedExports(
		source,
		module,
		moduleGraph,
		runtime,
		exports,
		alreadyRenderedExports
	) {
		const result = new ConcatSource(source);
		/** @type {Set<string>} */
		const moduleRequests = new Set();
		/** @type {Map<string, string | InlinedUsedName>} */
		const unknownProvidedExports = new Map();

		/**
		 * Resolves dynamic star reexport.
		 * @param {Module} module the module
		 * @param {boolean} isDynamicReexport if module is dynamic reexported
		 */
		const resolveDynamicStarReexport = (module, isDynamicReexport) => {
			for (const connection of moduleGraph.getOutgoingConnections(module)) {
				const dep = connection.dependency;

				// Only handle star-reexport statement
				if (
					dep instanceof HarmonyExportImportedSpecifierDependency &&
					dep.name === null
				) {
					const importedModule = connection.resolvedModule;
					const importedModuleExportsInfo =
						moduleGraph.getExportsInfo(importedModule);

					// The imported module provides unknown exports
					// So keep the reexports rendered in the bundle
					if (
						dep.getMode(moduleGraph, runtime).type === "dynamic-reexport" &&
						importedModuleExportsInfo._otherExportsInfo.provided === null
					) {
						// Handle export * from 'external'
						if (importedModule instanceof ExternalModule) {
							moduleRequests.add(importedModule.userRequest);
						} else {
							resolveDynamicStarReexport(importedModule, true);
						}
					}
					// If importer modules existing `dynamic-reexport` dependency
					// We should keep export statement rendered in the bundle
					else if (isDynamicReexport) {
						for (const exportInfo of importedModuleExportsInfo.orderedExports) {
							if (!exportInfo.provided || exportInfo.name === "default") {
								continue;
							}
							const originalName = exportInfo.name;
							const usedName =
								/** @type {string | InlinedUsedName | false} */
								(exportInfo.getUsedName(originalName, runtime));

							if (!alreadyRenderedExports.has(originalName) && usedName) {
								unknownProvidedExports.set(originalName, usedName);
							}
						}
					}
				}
			}
		};

		resolveDynamicStarReexport(module, false);

		for (const request of moduleRequests) {
			result.add(`export * from "${request}";\n`);
		}

		for (const [origin, used] of unknownProvidedExports) {
			exports.push([
				origin,
				used instanceof InlinedUsedName
					? used.render(
							Template.toNormalComment(
								`inlined export ${propertyAccess([origin])}`
							)
						)
					: `${RuntimeGlobals.exports}${propertyAccess([used])}`
			]);
		}

		return result;
	}

	/**
	 * Renders source with library export.
	 * @param {Source} source source
	 * @param {Module} module module
	 * @param {StartupRenderContext} renderContext render context
	 * @param {LibraryContext<T>} libraryContext context
	 * @returns {Source} source with library export
	 */
	renderStartup(source, module, renderContext, { options, compilation }) {
		const {
			moduleGraph,
			chunk,
			codeGenerationResults,
			inlined,
			inlinedInIIFE,
			runtimeTemplate
		} = renderContext;
		let result = new ConcatSource(source);
		const exportInfos = options.export
			? [
					moduleGraph.getExportInfo(
						module,
						Array.isArray(options.export) ? options.export[0] : options.export
					)
				]
			: moduleGraph.getExportsInfo(module).orderedExports;

		const exportsFinalNameByRuntime =
			(module.buildMeta &&
				module.buildMeta.exportsFinalNameByRuntime &&
				module.buildMeta.exportsFinalNameByRuntime.get(
					getRuntimeKey(chunk.runtime)
				)) ||
			{};

		const isInlinedEntryWithoutIIFE = inlined && !inlinedInIIFE;
		// Direct export bindings from on-demand concatenation
		const definitions = isInlinedEntryWithoutIIFE
			? exportsFinalNameByRuntime
			: {};

		/** @type {string[]} */
		const shortHandedExports = [];
		/** @type {[string, string][]} */
		const exports = [];
		/** @type {Set<string>} */
		const alreadyRenderedExports = new Set();
		/** @type {Set<string>} */
		const usedLocalNames = new Set();

		/**
		 * `toIdentifier` is lossy, so distinct export names (`"a b"` and `"a-b"`)
		 * would otherwise be bound to the same generated name twice.
		 * @param {string} exportName export name
		 * @returns {string} unique local name for the export
		 */
		const toLocalName = (exportName) => {
			const base = `${RuntimeGlobals.exports}${Template.toIdentifier(exportName)}`;
			let name = base;
			let i = 0;
			while (usedLocalNames.has(name)) name = `${base}_${i++}`;
			usedLocalNames.add(name);
			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
						);
					}
				}
			}
		}

		// 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)
			)
		);

		const moduleExportsInfo = moduleGraph.getExportsInfo(module);

		// Define ESM compatibility flag will rely on `__webpack_exports__`
		const needHarmonyCompatibilityFlag =
			moduleExportsInfo.otherExportsInfo.getUsed(chunk.runtime) !==
				UsageState.Unused ||
			moduleExportsInfo
				.getReadOnlyExportInfo("__esModule")
				.getUsed(chunk.runtime) !== UsageState.Unused;

		let needExportsDeclaration =
			!isInlinedEntryWithoutIIFE || isAsync || needHarmonyCompatibilityFlag;

		if (isAsync) {
			result.add(
				`${RuntimeGlobals.exports} = await ${RuntimeGlobals.exports};\n`
			);
		}

		// Try to find all known exports of the entry module
		outer: 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;

			// 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;
					}
				}
			}

			// The exports of entry module are never inlined
			const usedName =
				/** @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
				finalName = toLocalName(originalName);
				needExportsDeclaration = true;
				result.add(
					`${runtimeTemplate.renderConst()} ${finalName} = ${RuntimeGlobals.exports}${propertyAccess(
						[usedName]
					)};\n`
				);
			}

			if (
				// If the name includes `property access` and `call expressions`
				finalName &&
				(finalName.includes(".") ||
					finalName.includes("[") ||
					finalName.includes("("))
			) {
				if (exportInfo.isReexport()) {
					const { data } = codeGenerationResults.get(module, chunk.runtime);
					const topLevelDeclarations =
						(data && data.get("topLevelDeclarations")) ||
						(module.buildInfo && module.buildInfo.topLevelDeclarations);

					if (topLevelDeclarations && topLevelDeclarations.has(originalName)) {
						const name = toLocalName(originalName);
						result.add(
							`${runtimeTemplate.renderConst()} ${name} = ${finalName};\n`
						);
						shortHandedExports.push(`${name} as ${toExportName(originalName)}`);
					} else {
						exports.push([originalName, finalName]);
					}
				} else {
					exports.push([originalName, finalName]);
				}
			} else {
				shortHandedExports.push(
					finalName === originalName
						? finalName
						: `${finalName} as ${toExportName(originalName)}`
				);
			}

			alreadyRenderedExports.add(originalName);
		}

		if (shortHandedExports.length > 0) {
			result.add(`export { ${shortHandedExports.join(", ")} };\n`);
		}

		// Add default export `__webpack_exports__` statement to keep better compatibility
		if (treatAsCommonJs) {
			needExportsDeclaration = true;
			result.add(`export default ${RuntimeGlobals.exports};\n`);
		}

		result = this._analyzeUnknownProvidedExports(
			result,
			module,
			moduleGraph,
			chunk.runtime,
			exports,
			alreadyRenderedExports
		);

		for (const [exportName, final] of exports) {
			if (isDeclarableExportName(exportName)) {
				result.add(
					`export ${runtimeTemplate.renderConst()} ${exportName} = ${final};\n`
				);
				continue;
			}
			// Bind to a generated name, the export name can't be declared
			const name = toLocalName(exportName);
			result.add(
				`${runtimeTemplate.renderConst()} ${name} = ${final};\nexport { ${name} as ${toExportName(exportName)} };\n`
			);
		}

		if (!needExportsDeclaration) {
			renderContext.needExportsDeclaration = false;
		}

		return result;
	}

	/**
	 * Renders module content.
	 * @param {Source} source source
	 * @param {Module} module module
	 * @param {ModuleRenderContext} renderContext render context
	 * @param {Omit<LibraryContext<T>, "options">} libraryContext context
	 * @returns {Source} source with library export
	 */
	renderModuleContent(
		source,
		module,
		{ factory, inlinedInIIFE, chunk },
		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);

		// 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.
		if ((inlinedInIIFE || factory) && (exportsSource || bindingSource)) {
			return new ConcatSource(
				...(exportsSource ? [exportsSource] : []),
				source,
				...(bindingSource ? ["\n", bindingSource] : [])
			);
		}
		return source;
	}
}

module.exports = ModuleLibraryPlugin;