webpack 5.112.0 → 5.112.2

package/lib/json/JsonGenerator.js

@@ -12,6 +12,7 @@ const { JAVASCRIPT_TYPES } = require("../module/ModuleSourceTypeConstants");
 const ConcatenationScope = require("../optimize/ConcatenationScope");
 const RuntimeGlobals = require("../runtime/RuntimeGlobals");
 
+/** @import { JsonNormalModule } from "./JsonModule" */
 /** @import { Source } from "webpack-sources" */
 /** @import { JsonGeneratorOptions } from "../../declarations/WebpackOptions" */
 /** @import ExportsInfo from "../graph/ExportsInfo" */
@@ -24,7 +25,6 @@ const RuntimeGlobals = require("../runtime/RuntimeGlobals");
  * 	SourceTypes
  * } from "../module/Module"
  */
-/** @import NormalModule from "../module/NormalModule" */
 /** @import { RuntimeSpec } from "../util/runtime" */
 /** @import { JsonArray, JsonObject, JsonValue } from "../fs/fs" */
 
@@ -145,6 +145,14 @@ const createObjectForExportsInfo = (data, exportsInfo, runtime) => {
 	return reducedData;
 };
 
+/**
+ * The module type the JSDoc inherited from `Generator` names.
+ * @typedef {JsonNormalModule} TModule
+ */
+
+/**
+ * @extends {Generator<TModule>}
+ */
 class JsonGenerator extends Generator {
 	/**
 	 * Creates an instance of JsonGenerator.
@@ -158,7 +166,7 @@ class JsonGenerator extends Generator {
 
 	/**
 	 * Returns the source types available for this module.
-	 * @param {NormalModule} module fresh module
+	 * @param {TModule} module fresh module
 	 * @returns {SourceTypes} available types (do not mutate)
 	 */
 	getTypes(module) {
@@ -167,7 +175,7 @@ class JsonGenerator extends Generator {
 
 	/**
 	 * Returns the estimated size for the requested source type.
-	 * @param {NormalModule} module the module
+	 * @param {TModule} module the module
 	 * @param {SourceType=} type source type
 	 * @returns {number} estimate size of the module
 	 */
@@ -183,7 +191,7 @@ class JsonGenerator extends Generator {
 
 	/**
 	 * Returns the reason this module cannot be concatenated, when one exists.
-	 * @param {NormalModule} module module for which the bailout reason should be determined
+	 * @param {TModule} module module for which the bailout reason should be determined
 	 * @param {ConcatenationBailoutReasonContext} context context
 	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
 	 */
@@ -193,7 +201,7 @@ class JsonGenerator extends Generator {
 
 	/**
 	 * Generates generated code for this runtime module.
-	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {TModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
 	 * @returns {Source | null} generated code
 	 */
@@ -254,7 +262,7 @@ class JsonGenerator extends Generator {
 	/**
 	 * Generates fallback output for the provided error condition.
 	 * @param {Error} error the error
-	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {TModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
 	 * @returns {Source | null} generated code
 	 */
@@ -271,7 +279,7 @@ class JsonGenerator extends Generator {
 	/**
 	 * Updates the hash with the data contributed by this instance.
 	 * @param {Hash} hash hash that will be modified
-	 * @param {UpdateHashContext} updateHashContext context for updating hash
+	 * @param {UpdateHashContext<TModule>} updateHashContext context for updating hash
 	 */
 	updateHash(hash, updateHashContext) {
 		if (this.options.JSONParse) {

package/lib/json/JsonModule.js

@@ -14,6 +14,7 @@ const makeSerializable = require("../util/makeSerializable");
  * } from "../module/NormalModule"
  */
 /** @import JsonData from "./JsonData" */
+/** @import { BuildMeta } from "../module/Module" */
 
 /**
  * Defines the build info properties specific to json modules.
@@ -23,6 +24,16 @@ const makeSerializable = require("../util/makeSerializable");
 
 /** @typedef {NormalModuleBuildInfo & KnownJsonModuleBuildInfo} JsonModuleBuildInfo */
 
+/**
+ * A json module before or after its build, typed with its build info.
+ * @typedef {NormalModule & { buildInfo?: JsonModuleBuildInfo }} JsonNormalModule
+ */
+
+/**
+ * A built json module, typed with its build info and build meta.
+ * @typedef {NormalModule & { buildInfo: JsonModuleBuildInfo, buildMeta: BuildMeta }} BuiltJsonModule
+ */
+
 /**
  * Module class for `json` modules. JSON-specific properties should live here instead of `NormalModule`.
  */

package/lib/json/JsonParser.js

@@ -10,9 +10,8 @@ const parseJson = require("../util/parseJson");
 const JsonData = require("./JsonData");
 const JsonExportsDependency = require("./JsonExportsDependency");
 
+/** @import { BuiltJsonModule } from "./JsonModule" */
 /** @import { JsonParserOptions } from "../../declarations/WebpackOptions" */
-/** @import { JsonModuleBuildInfo } from "./JsonModule" */
-/** @import { BuildMeta } from "../module/Module" */
 /** @import { ParserState, PreparsedAst } from "../module/Parser" */
 /** @import { JsonValue } from "../fs/fs" */
 
@@ -24,6 +23,9 @@ const JsonExportsDependency = require("./JsonExportsDependency");
  * @typedef {import("../util/memoize").FunctionReturning<T>} FunctionReturning
  */
 
+/**
+ * @extends {Parser<BuiltJsonModule>}
+ */
 class JsonParser extends Parser {
 	/**
 	 * Creates an instance of JsonParser.
@@ -53,13 +55,12 @@ class JsonParser extends Parser {
 			typeof source === "object"
 				? source
 				: parseFn(source[0] === "\uFEFF" ? source.slice(1) : source);
-		const jsonData = new JsonData(/** @type {Buffer | JsonValue} */ (data));
-		const buildInfo = /** @type {JsonModuleBuildInfo} */ (
-			state.module.buildInfo
+		const jsonData = new JsonData(data);
+		const { buildInfo, buildMeta } = /** @type {BuiltJsonModule} */ (
+			state.module
 		);
 		buildInfo.jsonData = jsonData;
 		buildInfo.strict = true;
-		const buildMeta = /** @type {BuildMeta} */ (state.module.buildMeta);
 		buildMeta.exportsType = "default";
 		buildMeta.defaultObject =
 			typeof data === "object"

package/lib/library/AssignLibraryPlugin.js

@@ -46,7 +46,7 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 const KEYWORD_REGEX =
 	/^(?:await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|implements|import|in|instanceof|interface|let|new|null|package|private|protected|public|return|super|switch|static|this|throw|try|true|typeof|var|void|while|with|yield)$/;
 const IDENTIFIER_REGEX =
-	/^[\p{L}\p{Nl}$_][\p{L}\p{Nl}$\p{Mn}\p{Mc}\p{Nd}\p{Pc}]*$/iu;
+	/^[\p{L}\p{Nl}$_][\p{L}\p{Nl}$\p{Mn}\p{Mc}\p{Nd}\p{Pc}]*$/u;
 
 /**
  * Validates the library name by checking for keywords and valid characters

package/lib/library/JsonpLibraryPlugin.js

@@ -67,7 +67,7 @@ class JsonpLibraryPlugin extends AbstractLibraryPlugin {
 				`Jsonp library name must be a simple string. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
 			);
 		}
-		const _name = /** @type {string} */ (name);
+		const _name = name;
 		return {
 			name: _name
 		};

package/lib/library/ModuleLibraryPlugin.js

@@ -6,6 +6,8 @@
 "use strict";
 
 const { ConcatSource } = require("webpack-sources");
+const ESMLiveExportDependency = require("../dependencies/esm/ESMLiveExportDependency");
+const ESMLiveExportParserPlugin = require("../dependencies/esm/ESMLiveExportParserPlugin");
 const ExternalStarReexportError = require("../errors/ExternalStarReexportError");
 const { UsageState } = require("../graph/ExportsInfo");
 const isDependencyKind = require("../graph/isDependencyKind");
@@ -15,20 +17,28 @@ const {
 	mergedEntryModules
 } = require("../javascript/MergedEntryExports");
 const { JAVASCRIPT_TYPE } = require("../module/ModuleSourceTypeConstants");
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("../module/ModuleTypeConstants");
 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 { SAFE_IDENTIFIER, propertyAccess } = require("../util/property");
 const {
-	RESERVED_IDENTIFIER,
-	SAFE_IDENTIFIER,
-	propertyAccess
-} = require("../util/property");
-const { getEntryRuntime, intersectRuntime } = require("../util/runtime");
+	getEntryRuntime,
+	getRuntimeKey,
+	intersectRuntime
+} = require("../util/runtime");
 const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 
 /** @import ExternalModule from "../externals/ExternalModule" */
+/** @import { ExportInfo } from "../graph/ExportsInfo" */
+/** @import Chunk from "../graph/Chunk" */
+/** @import ESMExportSpecifierDependency from "../dependencies/esm/ESMExportSpecifierDependency" */
+/** @import NormalModuleFactory from "../module/NormalModuleFactory" */
 /** @import { InlinedUsedName } from "../optimize/InlineExports" */
 /** @import { Source } from "webpack-sources" */
 /**
@@ -41,8 +51,10 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /** @import CodeGenerationResults from "../module/CodeGenerationResults" */
 /** @import Compilation from "../Compilation" */
 /** @import Compiler from "../Compiler" */
-/** @import ModuleGraph from "../graph/ModuleGraph" */
+/** @import ModuleGraph, { LiveBinding } from "../graph/ModuleGraph" */
 /** @import Module from "../module/Module" */
+/** @import ChunkGraph from "../graph/ChunkGraph" */
+/** @import RuntimeTemplate from "../template/RuntimeTemplate" */
 /**
  * @import {
  * 	StartupRenderContext,
@@ -84,6 +96,102 @@ const PLUGIN_NAME = "ModuleLibraryPlugin";
  */
 const libraryEntryModules = new WeakMap();
 
+/**
+ * @typedef {object} ChunkLiveExports
+ * @property {string[]} names the names the chunk's scope declares
+ * @property {Map<InstanceType<ExportInfo>, string>} exports the name each live export binds to
+ * @property {[string, string, string, string | false, boolean][]} setters the module id, local name, declared name, used export name and async status of each binding a module writes through a setter
+ * @property {boolean} hasAsync whether any setter belongs to an async module
+ */
+
+/**
+ * @typedef {object} LiveExportCandidate
+ * @property {Module} module the module declaring the binding
+ * @property {ESMLiveExportDependency} declaration its declaration
+ * @property {InstanceType<ExportInfo>} exportInfo the library's export of it
+ * @property {string} localName the local name the export binds to
+ * @property {boolean} mirrored whether the module keeps its declaration and mirrors each write
+ */
+
+/** @type {WeakMap<Chunk, ChunkLiveExports>} */
+const chunkLiveExports = new WeakMap();
+
+/** @type {WeakSet<NormalModuleFactory>} */
+const liveExportFactories = new WeakSet();
+
+/** @type {WeakMap<Compilation, Set<string>>} */
+const hoistedNames = new WeakMap();
+
+/**
+ * @typedef {object} ModuleLocalExports
+ * @property {Map<string, ESMExportSpecifierDependency>} specifiers each local export by its name
+ * @property {Map<string, ESMLiveExportDependency>} declarations each live `let` by a name it declares
+ */
+
+/**
+ * Indexes the local exports and live `let` declarations of a module, once per module.
+ * @param {Module} module the module
+ * @param {Map<Module, ModuleLocalExports>} cache the indexes built so far
+ * @returns {ModuleLocalExports} the module's index
+ */
+const getModuleLocalExports = (module, cache) => {
+	let result = cache.get(module);
+	if (result !== undefined) return result;
+	result = { specifiers: new Map(), declarations: new Map() };
+	for (const dependency of module.dependencies) {
+		if (isDependencyKind(dependency, "esm-export-specifier")) {
+			result.specifiers.set(dependency.name, dependency);
+		} else if (isDependencyKind(dependency, "esm-live-export")) {
+			for (const name of dependency.names) {
+				result.declarations.set(name, dependency);
+			}
+		}
+	}
+	cache.set(module, result);
+	return result;
+};
+
+/**
+ * Why a module's exported module-level bindings cannot move to the chunk's scope.
+ * @param {Module} module the module declaring them
+ * @param {Module} entry the entry module exporting them
+ * @param {ESMLiveExportDependency} declaration one of its declarations
+ * @returns {string | null} the reason they stay and mirror, empty where they are live already, null where they can move
+ */
+const getHoistRefusal = (module, entry, declaration) => {
+	// A concatenation puts its modules' bindings in one scope already.
+	if (
+		module.is("concatenated") ||
+		(entry !== module &&
+			someInIterable(entry.getSourceModules(), (source) => source === module))
+	) {
+		return "";
+	}
+	if (declaration.readByEval) {
+		return "the module calls eval(), and a function it creates may write a binding later";
+	}
+	return null;
+};
+
+/**
+ * Whether a module's code runs where the chunk's scope is not: in a hot update, or in
+ * another chunk of the runtime, so it can reach the declared names only through setters.
+ * @param {Module} module the module declaring them
+ * @param {ESMLiveExportDependency} declaration one of its declarations
+ * @param {Chunk} chunk the library's chunk
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @returns {boolean} true when the module needs the setters
+ */
+const needsSetters = (module, declaration, chunk, chunkGraph) =>
+	declaration.hot ||
+	!chunkGraph.isModuleInChunk(module, chunk) ||
+	someInIterable(
+		chunkGraph.getModuleChunksIterable(module),
+		(other) =>
+			other !== chunk &&
+			intersectRuntime(other.runtime, chunk.runtime) !== undefined
+	);
+
 /**
  * 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.
@@ -109,14 +217,6 @@ const noNativeExports = (module, moduleGraph) => {
 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
@@ -142,10 +242,34 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 	apply(compiler) {
 		super.apply(compiler);
 
+		// Both library types apply this plugin, and one parser tap records everything.
+		compiler.hooks.normalModuleFactory.tap(
+			PLUGIN_NAME,
+			(normalModuleFactory) => {
+				if (liveExportFactories.has(normalModuleFactory)) return;
+				liveExportFactories.add(normalModuleFactory);
+				for (const type of [
+					JAVASCRIPT_MODULE_TYPE_AUTO,
+					JAVASCRIPT_MODULE_TYPE_ESM
+				]) {
+					normalModuleFactory.hooks.parser
+						.for(type)
+						.tap(PLUGIN_NAME, (parser) => {
+							new ESMLiveExportParserPlugin().apply(parser);
+						});
+				}
+			}
+		);
+
 		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
 			const javascriptHooks =
 				JavascriptModulesPlugin.getCompilationHooks(compilation);
 
+			compilation.dependencyTemplates.set(
+				ESMLiveExportDependency,
+				new ESMLiveExportDependency.Template()
+			);
+
 			compilation.hooks.beforeCodeGeneration.tap(PLUGIN_NAME, () => {
 				const entries = libraryEntryModules.get(compilation);
 				if (entries === undefined) return;
@@ -164,8 +288,214 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 				}
 			});
 
+			// An exported module-level `let` or `var` of a module the chunk runs as a function
+			// moves to the chunk's scope under a reserved name, which the library then
+			// exports itself; decided before hashing, as the module's code changes.
+			compilation.hooks.beforeModuleHash.tap(PLUGIN_NAME, () => {
+				const entries = libraryEntryModules.get(compilation);
+				if (entries === undefined) return;
+				const { chunkGraph, moduleGraph } = compilation;
+				/** @type {Map<Module, ModuleLocalExports>} */
+				const localExports = new Map();
+				// Both library types name bindings in one compilation, so they share it.
+				let usedNames = hoistedNames.get(compilation);
+				if (usedNames === undefined) {
+					usedNames = new Set();
+					hoistedNames.set(compilation, usedNames);
+				}
+				/** @type {Map<Module, Set<string>>} */
+				const registeredRuntimes = new Map();
+				/** @type {{ chunk: Chunk, runtimeKey: string, candidates: LiveExportCandidate[] }[]} */
+				const chunkCandidates = [];
+				for (const chunk of compilation.chunks) {
+					if (chunkGraph.getNumberOfEntryModules(chunk) === 0) continue;
+					const entryOptions = chunk.getEntryOptions();
+					const library =
+						entryOptions && entryOptions.library !== undefined
+							? entryOptions.library
+							: compilation.outputOptions.library;
+					if (this._parseOptionsCached(library) === false) continue;
+					const runtimeKey = getRuntimeKey(chunk.runtime);
+					/** @type {LiveExportCandidate[]} */
+					const candidates = [];
+					// why each module keeps its bindings, null where they move
+					/** @type {Map<Module, string | null>} */
+					const refusals = new Map();
+					for (const entry of chunkGraph.getChunkEntryModulesIterable(chunk)) {
+						if (!entries.has(entry.getRootModule())) continue;
+						for (const exportInfo of moduleGraph.getExportsInfo(entry)
+							.orderedExports) {
+							if (!exportInfo.provided) continue;
+							const target = exportInfo.getTarget(moduleGraph);
+							if (target && (!target.export || target.export.length !== 1)) {
+								continue;
+							}
+							const module = target ? target.module : entry;
+							const { specifiers, declarations } = getModuleLocalExports(
+								module,
+								localExports
+							);
+							const local = specifiers.get(
+								target
+									? /** @type {string[]} */ (target.export)[0]
+									: exportInfo.name
+							);
+							const declaration = local && declarations.get(local.id);
+							if (!declaration) continue;
+							let refusal = refusals.get(module);
+							if (refusal === undefined) {
+								refusal = getHoistRefusal(module, entry, declaration);
+								refusals.set(module, refusal);
+								if (refusal) {
+									compilation.runtimeTemplate.analyzableBailout(
+										module,
+										`a module library may export a stale binding, since ${refusal}`
+									);
+								}
+							}
+							if (refusal === "") continue;
+							candidates.push({
+								module,
+								declaration,
+								exportInfo,
+								localName: local.id,
+								mirrored: declaration.earlyUse || refusal !== null
+							});
+							// A module runs once per runtime, so one library of it needing the
+							// setters makes every library of that runtime register them.
+							if (needsSetters(module, declaration, chunk, chunkGraph)) {
+								let runtimes = registeredRuntimes.get(module);
+								if (runtimes === undefined) {
+									runtimes = new Set();
+									registeredRuntimes.set(module, runtimes);
+								}
+								runtimes.add(runtimeKey);
+							}
+						}
+					}
+					if (candidates.length > 0) {
+						chunkCandidates.push({ chunk, runtimeKey, candidates });
+					}
+				}
+				for (const { chunk, runtimeKey, candidates } of chunkCandidates) {
+					/** @type {string[]} */
+					const names = [];
+					/** @type {Set<LiveBinding>} */
+					const declared = new Set();
+					/** @type {ChunkLiveExports["exports"]} */
+					const exports = new Map();
+					/** @type {ChunkLiveExports["setters"]} */
+					const setters = [];
+					/** @type {Map<Module, { runtimeKeys: string[], usedExports: Map<string, string> }>} */
+					const moduleRuntimeInfo = new Map();
+					let hasAsync = false;
+					for (const {
+						module,
+						declaration,
+						exportInfo,
+						localName,
+						mirrored
+					} of candidates) {
+						const runtimes = registeredRuntimes.get(module);
+						const registered =
+							runtimes !== undefined && runtimes.has(runtimeKey);
+						const isAsync = registered && moduleGraph.isAsync(module);
+						const meta = moduleGraph.getMeta(module);
+						// Renaming takes the module's own declaration, which an early use needs in
+						// order to throw and eval() to read, so such a module mirrors each write.
+						const bindings =
+							registered || mirrored
+								? meta.liveSetters || (meta.liveSetters = new Map())
+								: meta.liveBindings || (meta.liveBindings = new Map());
+						for (const name of declaration.names) {
+							let binding = bindings.get(name);
+							if (binding === undefined) {
+								let hoisted = `__webpack_live_${name}__`;
+								for (let i = 1; usedNames.has(hoisted); i++) {
+									hoisted = `__webpack_live_${name}_${i}__`;
+								}
+								usedNames.add(hoisted);
+								binding = {
+									name: hoisted,
+									runtimes: new Set(),
+									registered: new Set()
+								};
+								bindings.set(name, binding);
+							}
+							if (declared.has(binding)) continue;
+							declared.add(binding);
+							binding.runtimes.add(runtimeKey);
+							names.push(binding.name);
+							if (!registered) continue;
+							binding.registered.add(runtimeKey);
+							let runtimeInfo = moduleRuntimeInfo.get(module);
+							if (runtimeInfo === undefined) {
+								runtimeInfo = { runtimeKeys: [], usedExports: new Map() };
+								// Shared chunks generate the module for a union of runtimes;
+								// guarded setters apply when any of them registers this binding.
+								for (const runtime of chunkGraph.getModuleRuntimes(module)) {
+									if (intersectRuntime(runtime, chunk.runtime) === undefined) {
+										continue;
+									}
+									runtimeInfo.runtimeKeys.push(getRuntimeKey(runtime));
+								}
+								const exportsInfo = moduleGraph.getExportsInfo(module);
+								for (const [exportName, specifier] of getModuleLocalExports(
+									module,
+									localExports
+								).specifiers) {
+									// A module that already ran seeds the binding from its first used alias.
+									if (runtimeInfo.usedExports.has(specifier.id)) continue;
+									const usedName = exportsInfo.getUsedName(
+										exportName,
+										chunk.runtime
+									);
+									if (typeof usedName === "string") {
+										runtimeInfo.usedExports.set(specifier.id, usedName);
+									}
+								}
+								moduleRuntimeInfo.set(module, runtimeInfo);
+							}
+							for (const key of runtimeInfo.runtimeKeys) {
+								binding.runtimes.add(key);
+								binding.registered.add(key);
+							}
+							const used = runtimeInfo.usedExports.get(name);
+							hasAsync = hasAsync || isAsync;
+							setters.push([
+								JSON.stringify(chunkGraph.getModuleId(module)),
+								name,
+								binding.name,
+								used === undefined ? false : used,
+								isAsync
+							]);
+						}
+						exports.set(
+							exportInfo,
+							/** @type {LiveBinding} */ (bindings.get(localName)).name
+						);
+					}
+					if (names.length > 0) {
+						chunkLiveExports.set(chunk, { names, exports, setters, hasAsync });
+					}
+				}
+			});
+
 			// 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) => {
+					const live = chunkLiveExports.get(chunk);
+					if (live && live.setters.length > 0) {
+						set.add(RuntimeGlobals.moduleCache);
+						if (live.hasAsync) {
+							set.add(RuntimeGlobals.asyncModuleExportSymbol);
+						}
+					}
+				}
+			);
+
 			compilation.hooks.additionalChunkRuntimeRequirements.tap(
 				PLUGIN_NAME,
 				(chunk, set, { chunkGraph, codeGenerationResults }) => {
@@ -550,7 +880,15 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 			exportsAwaited,
 			runtimeTemplate
 		} = renderContext;
-		let result = new ConcatSource(source);
+		const live = chunkLiveExports.get(chunk);
+		// Declared before the startup runs the module functions assigning them
+		let result = live
+			? new ConcatSource(
+					`${runtimeTemplate.renderLet()} ${live.names.join(", ")};\n`,
+					this._renderLiveExportSetters(live, runtimeTemplate),
+					source
+				)
+			: 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);
@@ -707,7 +1045,13 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 			/** @type {string | undefined} */
 			let finalName;
 
-			if (definition) {
+			const liveName = live && live.exports.get(exportInfo);
+
+			if (liveName) {
+				finalName = liveName;
+				// the body still defines an export it does not leave out on the object
+				if (!definition) needExportsDeclaration = true;
+			} else if (definition) {
 				finalName = definition;
 			} else {
 				// Fallback to `__webpack_exports__` property access
@@ -777,13 +1121,8 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		);
 
 		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
+			// A declaration under the export's own name would shadow a global of that
+			// name every module of the chunk may read, so a generated name binds it.
 			const name = toLocalName(exportName);
 			result.add(
 				`${runtimeTemplate.renderConst()} ${name} = ${final};\nexport { ${name} as ${toExportName(exportName)} };\n`
@@ -797,6 +1136,43 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		return result;
 	}
 
+	/**
+	 * Renders the setters through which hot modules, an update included, write the
+	 * bindings the chunk's scope declares; a list per name, as several libraries may.
+	 * A module that ran before the chunk loaded hands over its value through its exports.
+	 * @param {ChunkLiveExports} live the chunk's live bindings
+	 * @param {RuntimeTemplate} runtimeTemplate the runtime template
+	 * @returns {string} the registrations
+	 */
+	_renderLiveExportSetters({ setters, hasAsync }, runtimeTemplate) {
+		if (setters.length === 0) return "";
+		const exports = hasAsync
+			? `(isAsync ? module.exports[${RuntimeGlobals.asyncModuleExportSymbol}] : module.exports)`
+			: "module.exports";
+		const register = "__webpack_live_register__";
+		return Template.asString([
+			`var ${register} = ${runtimeTemplate.basicFunction(
+				hasAsync ? "id, name, set, key, isAsync" : "id, name, set, key",
+				[
+					`var setters = ${RuntimeGlobals.liveExportSetters} = ${RuntimeGlobals.liveExportSetters} || {};`,
+					"setters = setters[id] = setters[id] || {};",
+					"(setters[name] = setters[name] || []).push(set);",
+					`var module = ${RuntimeGlobals.moduleCache}[id];`,
+					// A module still before its declaration throws, and hands the value over later.
+					`if (module && key) try { set(${exports}[key]); } catch (e) {}`
+				]
+			)};`,
+			...setters.map(
+				([id, name, hoisted, used, isAsync]) =>
+					`${register}(${id}, ${JSON.stringify(name)}, ${runtimeTemplate.basicFunction(
+						"value",
+						`${hoisted} = value;`
+					)}${used ? `, ${JSON.stringify(used)}${isAsync ? ", 1" : ""}` : ""});`
+			),
+			""
+		]);
+	}
+
 	/**
 	 * Renders module content.
 	 * @param {Source} source source