@depup/webpack 5.106.1-depup.0 → 5.109.2-depup.0

package/lib/RuntimeTemplate.js

@@ -6,20 +6,34 @@
 "use strict";
 
 const InitFragment = require("./InitFragment");
+const {
+	JAVASCRIPT_TYPE,
+	RUNTIME_TYPE
+} = require("./ModuleSourceTypeConstants");
+const {
+	WEBPACK_MODULE_TYPE_CONSUME_SHARED_MODULE,
+	WEBPACK_MODULE_TYPE_FALLBACK,
+	WEBPACK_MODULE_TYPE_PROVIDE,
+	WEBPACK_MODULE_TYPE_REMOTE
+} = require("./ModuleTypeConstants");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const Template = require("./Template");
 const {
 	getOutgoingAsyncModules
 } = require("./async-modules/AsyncModuleHelpers");
 const { ImportPhaseUtils } = require("./dependencies/ImportPhase");
+const { InlinedUsedName } = require("./optimize/InlineExports");
 const {
+	getDeferredCycleModuleIds,
+	getDeferredCycleModules,
 	getMakeDeferredNamespaceModeFromExportsType,
 	getOptimizedDeferredModule
 } = require("./runtime/MakeDeferredNamespaceObjectRuntime");
 const { equals } = require("./util/ArrayHelpers");
 const compileBooleanMatcher = require("./util/compileBooleanMatcher");
+const { getUndoPath, toJsStringLiteral } = require("./util/identifier");
 const memoize = require("./util/memoize");
-const { propertyAccess } = require("./util/property");
+const { propertyAccess, propertyName } = require("./util/property");
 const { forEachRuntime, subtractRuntime } = require("./util/runtime");
 
 const getHarmonyImportDependency = memoize(() =>
@@ -28,6 +42,28 @@ const getHarmonyImportDependency = memoize(() =>
 const getImportDependency = memoize(() =>
 	require("./dependencies/ImportDependency")
 );
+const getJavascriptModulesPlugin = memoize(() =>
+	require("./javascript/JavascriptModulesPlugin")
+);
+const getModuleHotAcceptDependency = memoize(() =>
+	require("./dependencies/ModuleHotAcceptDependency")
+);
+const getAPIPlugin = memoize(() => require("./APIPlugin"));
+
+// Module-federation module types whose chunks load through the federation runtime.
+/** @type {Set<string>} */
+const FEDERATION_MODULE_TYPES = new Set([
+	WEBPACK_MODULE_TYPE_REMOTE,
+	WEBPACK_MODULE_TYPE_PROVIDE,
+	WEBPACK_MODULE_TYPE_CONSUME_SHARED_MODULE,
+	WEBPACK_MODULE_TYPE_FALLBACK
+]);
+
+// Any `[hash]`/`[fullhash]`/`[chunkhash]`/`[contenthash]` token, incl. a `:<length>`
+// or `:<digest>[:<length>]` suffix (e.g. `[contenthash:base64:8]`). Its value is only
+// resolved after code generation, so a filename using one can't be an inline literal.
+const HASH_IN_FILENAME = /\[(?:full|chunk|content)?hash(?::[^\]]+)?\]/;
+const HASH_IN_FILENAME_GLOBAL = /\[(?:full|chunk|content)?hash(?::[^\]]+)?\]/g;
 
 /** @typedef {import("./config/defaults").OutputNormalizedWithDefaults} OutputOptions */
 /** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
@@ -45,6 +81,7 @@ const getImportDependency = memoize(() =>
 /** @typedef {import("./NormalModuleFactory").ModuleDependency} ModuleDependency */
 
 /**
+ * No module id error message.
  * @param {Module} module the module
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @returns {string} error message
@@ -63,14 +100,15 @@ It's in these chunks: ${
 Module has these incoming connections: ${Array.from(
 	chunkGraph.moduleGraph.getIncomingConnections(module),
 	(connection) =>
-		`\n - ${
-			connection.originModule && connection.originModule.identifier()
-		} ${connection.dependency && connection.dependency.type} ${
+		`\n - ${connection.originModule && connection.originModule.identifier()} ${
+			connection.dependency && connection.dependency.type
+		} ${
 			(connection.explanations && [...connection.explanations].join(", ")) || ""
 		}`
 ).join("")}`;
 
 /**
+ * Gets global object.
  * @param {string | undefined} definition global object definition
  * @returns {string | undefined} save to use global object
  */
@@ -94,17 +132,22 @@ function getGlobalObject(definition) {
 
 class RuntimeTemplate {
 	/**
+	 * Creates an instance of RuntimeTemplate.
 	 * @param {Compilation} compilation the compilation
 	 * @param {OutputOptions} outputOptions the compilation output options
 	 * @param {RequestShortener} requestShortener the request shortener
 	 */
 	constructor(compilation, outputOptions, requestShortener) {
+		/** @type {Compilation} */
 		this.compilation = compilation;
 		this.outputOptions = /** @type {OutputOptions} */ (outputOptions || {});
+		/** @type {RequestShortener} */
 		this.requestShortener = requestShortener;
+		/** @type {string} */
 		this.globalObject =
 			/** @type {string} */
 			(getGlobalObject(outputOptions.globalObject));
+		/** @type {string} */
 		this.contentHashReplacement = "X".repeat(outputOptions.hashDigestLength);
 	}
 
@@ -123,14 +166,59 @@ class RuntimeTemplate {
 		);
 	}
 
+	/**
+	 * Whether the bundle targets node and web at once (universal `["node", "web"]` + `output.module`), like `isUniversalTarget` in `WebpackOptionsApply`.
+	 * @returns {boolean} true for a universal target
+	 */
+	isUniversalTarget() {
+		const { platform } = this.compilation.compiler;
+		return (
+			Boolean(this.outputOptions.module) &&
+			platform.node === null &&
+			platform.web === null
+		);
+	}
+
+	/**
+	 * Runtime expression that is truthy in browser-like environments (a DOM
+	 * `document` or a worker `self`) and falsy in Node.js. Single source of
+	 * truth for branching a universal ("node-or-web") target at runtime.
+	 * @returns {string} runtime condition expression
+	 */
+	isWebLikePlatformExpression() {
+		return "typeof document !== 'undefined' || typeof self !== 'undefined'";
+	}
+
+	/**
+	 * Expression for the global registry that collects CSS server-side when there
+	 * is no DOM (SSR). An SSR host reads it from `globalThis`; it is keyed by the
+	 * style/chunk identifier and namespaced by `output.uniqueName`.
+	 * @returns {string} runtime expression evaluating to the registry object
+	 */
+	cssServerStyleRegistry() {
+		const name = this.outputOptions.uniqueName;
+		const key = JSON.stringify(
+			name ? `__webpack_css__${name}` : "__webpack_css__"
+		);
+		return `(${this.assignOr(`globalThis[${key}]`, "{}")})`;
+	}
+
 	supportsConst() {
 		return this.outputOptions.environment.const;
 	}
 
+	supportsLet() {
+		return this.outputOptions.environment.let;
+	}
+
 	supportsMethodShorthand() {
 		return this.outputOptions.environment.methodShorthand;
 	}
 
+	supportsLogicalAssignment() {
+		return this.outputOptions.environment.logicalAssignment;
+	}
+
 	supportsArrowFunction() {
 		return this.outputOptions.environment.arrowFunction;
 	}
@@ -139,10 +227,26 @@ class RuntimeTemplate {
 		return this.outputOptions.environment.asyncFunction;
 	}
 
+	supportsGenerator() {
+		return this.outputOptions.environment.generator;
+	}
+
 	supportsOptionalChaining() {
 		return this.outputOptions.environment.optionalChaining;
 	}
 
+	supportsSpread() {
+		return this.outputOptions.environment.spread;
+	}
+
+	supportsObjectHasOwn() {
+		return this.outputOptions.environment.hasOwn;
+	}
+
+	supportsSymbol() {
+		return this.outputOptions.environment.symbol;
+	}
+
 	supportsForOf() {
 		return this.outputOptions.environment.forOf;
 	}
@@ -163,6 +267,24 @@ class RuntimeTemplate {
 		return this.outputOptions.environment.module;
 	}
 
+	supportsModulePreload() {
+		return this.outputOptions.environment.modulePreload;
+	}
+
+	supportsAnalyzableEsm() {
+		// `eval` devtool wraps each module in `eval(...)`, where `import.meta` is a
+		// syntax error, so the literal `new URL(…, import.meta.url)` form can't be used.
+		const { devtool } = this.compilation.options;
+		return (
+			this.isModule() &&
+			this.supportsEcmaScriptModuleSyntax() &&
+			!(typeof devtool === "string" && devtool.includes("eval")) &&
+			// A runtime `__webpack_public_path__` override can't be reflected in a
+			// baked literal, so keep the runtime form that reads `__webpack_require__.p`.
+			!getAPIPlugin().usesRuntimePublicPathOverride(this.compilation)
+		);
+	}
+
 	supportTemplateLiteral() {
 		return this.outputOptions.environment.templateLiteral;
 	}
@@ -172,6 +294,7 @@ class RuntimeTemplate {
 	}
 
 	/**
+	 * Renders node prefix for core module.
 	 * @param {string} mod a module
 	 * @returns {string} a module with `node:` prefix when supported, otherwise an original name
 	 */
@@ -182,13 +305,23 @@ class RuntimeTemplate {
 	}
 
 	/**
-	 * @returns {"const" | "var"} return `const` when it is supported, otherwise `var`
+	 * Renders return const when it is supported, otherwise let when supported, otherwise var.
+	 * @returns {"const" | "let" | "var"} return `const` when it is supported, otherwise `let` when supported, otherwise `var`
 	 */
 	renderConst() {
-		return this.supportsConst() ? "const" : "var";
+		return this.supportsConst() ? "const" : this.supportsLet() ? "let" : "var";
 	}
 
 	/**
+	 * Renders return let when it is supported, otherwise var.
+	 * @returns {"let" | "var"} return `let` when it is supported, otherwise `var`
+	 */
+	renderLet() {
+		return this.supportsLet() ? "let" : "var";
+	}
+
+	/**
+	 * Returning function.
 	 * @param {string} returnValue return value
 	 * @param {string} args arguments
 	 * @returns {string} returning function
@@ -200,6 +333,7 @@ class RuntimeTemplate {
 	}
 
 	/**
+	 * Returns basic function.
 	 * @param {string} args arguments
 	 * @param {string | string[]} body body
 	 * @returns {string} basic function
@@ -211,6 +345,7 @@ class RuntimeTemplate {
 	}
 
 	/**
+	 * Returns result expression.
 	 * @param {(string | { expr: string })[]} args args
 	 * @returns {string} result expression
 	 */
@@ -260,6 +395,7 @@ class RuntimeTemplate {
 	}
 
 	/**
+	 * Returns result expression.
 	 * @param {(string | { expr: string })[]} args args (len >= 2)
 	 * @returns {string} result expression
 	 * @private
@@ -277,6 +413,7 @@ class RuntimeTemplate {
 	}
 
 	/**
+	 * Expression function.
 	 * @param {string} expression expression
 	 * @param {string} args arguments
 	 * @returns {string} expression function code
@@ -288,6 +425,7 @@ class RuntimeTemplate {
 	}
 
 	/**
+	 * Returns empty function code.
 	 * @returns {string} empty function code
 	 */
 	emptyFunction() {
@@ -295,34 +433,113 @@ class RuntimeTemplate {
 	}
 
 	/**
+	 * Guards an access/call on `object` with optional chaining when supported,
+	 * otherwise an equivalent `&&` short-circuit. `object` is evaluated twice in
+	 * the fallback, so it must be side-effect free.
+	 * @param {string} object base expression (side-effect free)
+	 * @param {string} access continuation after the optional point, e.g. `()`, `prop`, `method(arg)` or `[key]`
+	 * @returns {string} guarded access expression
+	 */
+	optionalChaining(object, access) {
+		if (this.supportsOptionalChaining()) {
+			return `${object}?.${access}`;
+		}
+		const sep = access[0] === "(" || access[0] === "[" ? "" : ".";
+		return `${object} && ${object}${sep}${access}`;
+	}
+
+	/**
+	 * Reads a node builtin via `process.getBuiltinModule()`, guarded to stay falsy off node so universal `["node", "web"]` bundles don't crash (also falsy on node <22.3).
+	 * @param {string} request builtin module request as a JS string expression, e.g. from `renderNodePrefixForCoreModule`
+	 * @param {string=} access member/call chain appended to the module, e.g. `.Worker` or `.createRequire(url)`
+	 * @returns {string} guarded expression
+	 */
+	getBuiltinModule(request, access = "") {
+		const getter = `process.getBuiltinModule(${request})${access}`;
+		if (this.outputOptions.environment.nodeBuiltinModuleGetter) {
+			return `typeof process !== "undefined" && ${getter}`;
+		}
+		return `typeof process !== "undefined" && typeof process.getBuiltinModule === "function" && ${getter}`;
+	}
+
+	/**
+	 * Renders an object-literal method, using method shorthand when supported
+	 * and falling back to a `prop: function/arrow` property otherwise.
+	 * @param {string} prop property name (or computed key like `[x]`)
+	 * @param {string} args arguments
+	 * @param {string | string[]} body body
+	 * @returns {string} method code
+	 */
+	method(prop, args, body) {
+		return this.supportsMethodShorthand()
+			? `${prop}(${args}) {\n${Template.indent(body)}\n}`
+			: `${prop}: ${this.basicFunction(args, body)}`;
+	}
+
+	/**
+	 * Returns an own-property check, using `Object.hasOwn` when supported and
+	 * falling back to `Object.prototype.hasOwnProperty.call` otherwise.
+	 * @param {string} object object expression
+	 * @param {string} property property expression
+	 * @returns {string} own-property check expression
+	 */
+	objectHasOwn(object, property) {
+		return this.supportsObjectHasOwn()
+			? `Object.hasOwn(${object}, ${property})`
+			: `Object.prototype.hasOwnProperty.call(${object}, ${property})`;
+	}
+
+	/**
+	 * Returns a self-defaulting assignment, using the `||=` logical assignment
+	 * operator when supported and falling back to `target = target || value`
+	 * otherwise. `target` is evaluated twice in the fallback, so it must be
+	 * side-effect free. The expression evaluates to the resulting value.
+	 * Models `||` only, so `target` must never hold a legitimate falsy value
+	 * (`0`, `""`, `false`) — it would be overwritten; use it for object/array defaults.
+	 * @param {string} target assignment target (side-effect free)
+	 * @param {string} value default value expression
+	 * @returns {string} assignment expression
+	 */
+	assignOr(target, value) {
+		return this.supportsLogicalAssignment()
+			? `${target} ||= ${value}`
+			: `${target} = ${target} || ${value}`;
+	}
+
+	/**
+	 * Returns destructure array code.
 	 * @param {string[]} items items
 	 * @param {string} value value
 	 * @returns {string} destructure array code
 	 */
 	destructureArray(items, value) {
+		const decl = this.renderLet();
 		return this.supportsDestructuring()
-			? `var [${items.join(", ")}] = ${value};`
+			? `${decl} [${items.join(", ")}] = ${value};`
 			: Template.asString(
-					items.map((item, i) => `var ${item} = ${value}[${i}];`)
+					items.map((item, i) => `${decl} ${item} = ${value}[${i}];`)
 				);
 	}
 
 	/**
+	 * Destructure object.
 	 * @param {string[]} items items
 	 * @param {string} value value
 	 * @returns {string} destructure object code
 	 */
 	destructureObject(items, value) {
+		const decl = this.renderLet();
 		return this.supportsDestructuring()
-			? `var {${items.join(", ")}} = ${value};`
+			? `${decl} {${items.join(", ")}} = ${value};`
 			: Template.asString(
 					items.map(
-						(item) => `var ${item} = ${value}${propertyAccess([item])};`
+						(item) => `${decl} ${item} = ${value}${propertyAccess([item])};`
 					)
 				);
 	}
 
 	/**
+	 * Returns iIFE code.
 	 * @param {string} args arguments
 	 * @param {string} body body
 	 * @returns {string} IIFE code
@@ -332,6 +549,7 @@ class RuntimeTemplate {
 	}
 
 	/**
+	 * Returns for each code.
 	 * @param {string} variable variable
 	 * @param {string} array array
 	 * @param {string | string[]} body body
@@ -346,7 +564,7 @@ class RuntimeTemplate {
 	}
 
 	/**
-	 * Add a comment
+	 * Returns comment.
 	 * @param {object} options Information content of the comment
 	 * @param {string=} options.request request string used originally
 	 * @param {(string | null)=} options.chunkName name of the chunk referenced
@@ -377,18 +595,20 @@ class RuntimeTemplate {
 	}
 
 	/**
+	 * Throw missing module error block.
 	 * @param {object} options generation options
 	 * @param {string=} options.request request string used originally
 	 * @returns {string} generated error block
 	 */
 	throwMissingModuleErrorBlock({ request }) {
 		const err = `Cannot find module '${request}'`;
-		return `var e = new Error(${JSON.stringify(
+		return `${this.renderConst()} e = new Error(${JSON.stringify(
 			err
 		)}); e.code = 'MODULE_NOT_FOUND'; throw e;`;
 	}
 
 	/**
+	 * Throw missing module error function.
 	 * @param {object} options generation options
 	 * @param {string=} options.request request string used originally
 	 * @returns {string} generated error function
@@ -400,6 +620,7 @@ class RuntimeTemplate {
 	}
 
 	/**
+	 * Returns generated error IIFE.
 	 * @param {object} options generation options
 	 * @param {string=} options.request request string used originally
 	 * @returns {string} generated error IIFE
@@ -409,6 +630,7 @@ class RuntimeTemplate {
 	}
 
 	/**
+	 * Missing module statement.
 	 * @param {object} options generation options
 	 * @param {string=} options.request request string used originally
 	 * @returns {string} generated error statement
@@ -418,6 +640,7 @@ class RuntimeTemplate {
 	}
 
 	/**
+	 * Missing module promise.
 	 * @param {object} options generation options
 	 * @param {string=} options.request request string used originally
 	 * @returns {string} generated error code
@@ -429,6 +652,7 @@ class RuntimeTemplate {
 	}
 
 	/**
+	 * Returns the code.
 	 * @param {object} options options object
 	 * @param {ChunkGraph} options.chunkGraph the chunk graph
 	 * @param {Module} options.module the module
@@ -448,9 +672,7 @@ class RuntimeTemplate {
 							`Module '${moduleId}' is not available (weak dependency)`
 						);
 		const comment = request ? `${Template.toNormalComment(request)} ` : "";
-		const errorStatements = `var e = new Error(${errorMessage}); ${
-			comment
-		}e.code = 'MODULE_NOT_FOUND'; throw e;`;
+		const errorStatements = `${this.renderConst()} e = new Error(${errorMessage}); ${comment}e.code = 'MODULE_NOT_FOUND'; throw e;`;
 		switch (type) {
 			case "statements":
 				return errorStatements;
@@ -465,6 +687,7 @@ class RuntimeTemplate {
 	}
 
 	/**
+	 * Returns the expression.
 	 * @param {object} options options object
 	 * @param {Module} options.module the module
 	 * @param {ChunkGraph} options.chunkGraph the chunk graph
@@ -494,6 +717,7 @@ class RuntimeTemplate {
 	}
 
 	/**
+	 * Returns the expression.
 	 * @param {object} options options object
 	 * @param {Module | null} options.module the module
 	 * @param {ChunkGraph} options.chunkGraph the chunk graph
@@ -537,6 +761,7 @@ class RuntimeTemplate {
 	}
 
 	/**
+	 * Returns the expression.
 	 * @param {object} options options object
 	 * @param {Module | null} options.module the module
 	 * @param {ChunkGraph} options.chunkGraph the chunk graph
@@ -556,6 +781,7 @@ class RuntimeTemplate {
 	}
 
 	/**
+	 * Returns the expression.
 	 * @param {object} options options object
 	 * @param {Module} options.module the module
 	 * @param {ChunkGraph} options.chunkGraph the chunk graph
@@ -625,6 +851,7 @@ class RuntimeTemplate {
 	}
 
 	/**
+	 * Module namespace promise.
 	 * @param {object} options options object
 	 * @param {ChunkGraph} options.chunkGraph the chunk graph
 	 * @param {AsyncDependenciesBlock=} options.block the current dependencies block
@@ -635,6 +862,7 @@ class RuntimeTemplate {
 	 * @param {boolean=} options.weak if the dependency is weak (will create a nice error message)
 	 * @param {Dependency} options.dependency dependency
 	 * @param {RuntimeRequirements} options.runtimeRequirements if set, will be filled with runtime requirements
+	 * @param {Module=} options.originModule the module the `import()` is emitted into
 	 * @returns {string} the promise expression
 	 */
 	moduleNamespacePromise({
@@ -646,7 +874,8 @@ class RuntimeTemplate {
 		strict,
 		weak,
 		dependency,
-		runtimeRequirements
+		runtimeRequirements,
+		originModule
 	}) {
 		if (!module) {
 			return this.missingModulePromise({
@@ -676,7 +905,8 @@ class RuntimeTemplate {
 			chunkGraph,
 			block,
 			message,
-			runtimeRequirements
+			runtimeRequirements,
+			originModule
 		});
 
 		/** @type {string} */
@@ -689,7 +919,7 @@ class RuntimeTemplate {
 		if (weak) {
 			if (idExpr.length > 8) {
 				// 'var x="nnnnnn";x,"+x+",x' vs '"nnnnnn",nnnnnn,"nnnnnn"'
-				header += `var id = ${idExpr}; `;
+				header += `${this.renderConst()} id = ${idExpr}; `;
 				idExpr = "id";
 			}
 			runtimeRequirements.add(RuntimeGlobals.moduleFactories);
@@ -725,11 +955,17 @@ class RuntimeTemplate {
 				if (header) {
 					appending = `.then(${this.basicFunction(
 						"",
-						`${header}return ${RuntimeGlobals.deferredModuleAsyncTransitiveDependencies}(${JSON.stringify(asyncDeps)});`
+						`${header}return ${
+							RuntimeGlobals.deferredModuleAsyncTransitiveDependencies
+						}(${JSON.stringify(asyncDeps)});`
 					)})`;
 				} else {
 					runtimeRequirements.add(RuntimeGlobals.require);
-					appending = `.then(${this.returningFunction(`${RuntimeGlobals.deferredModuleAsyncTransitiveDependencies}(${JSON.stringify(asyncDeps)})`)})`;
+					appending = `.then(${this.returningFunction(
+						`${
+							RuntimeGlobals.deferredModuleAsyncTransitiveDependencies
+						}(${JSON.stringify(asyncDeps)})`
+					)})`;
 				}
 				appending += `.then(${RuntimeGlobals.makeDeferredNamespaceObject}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}, ${mode}))`;
 			} else if (header) {
@@ -817,6 +1053,7 @@ class RuntimeTemplate {
 	}
 
 	/**
+	 * Runtime condition expression.
 	 * @param {object} options options object
 	 * @param {ChunkGraph} options.chunkGraph the chunk graph
 	 * @param {RuntimeSpec=} options.runtime runtime for which this code will be generated
@@ -854,6 +1091,7 @@ class RuntimeTemplate {
 	}
 
 	/**
+	 * Returns the import statement and the compat statement.
 	 * @param {object} options options object
 	 * @param {boolean=} options.update whether a new variable should be created or the existing one updated
 	 * @param {Module} options.module the module
@@ -915,6 +1153,10 @@ class RuntimeTemplate {
 			request,
 			weak
 		});
+		// Harmony imports may be wrapped in runtime-condition `if` blocks
+		// but referenced outside those blocks (e.g. by harmony reexport),
+		// so they must remain function-scoped (`var`) rather than
+		// block-scoped (`let`/`const`).
 		const optDeclaration = update ? "" : "var ";
 
 		const exportsType = module.getExportsType(
@@ -941,6 +1183,10 @@ class RuntimeTemplate {
 				moduleId,
 				exportsType,
 				Array.from(outgoingAsyncModules, (mod) => chunkGraph.getModuleId(mod)),
+				getDeferredCycleModuleIds(
+					getDeferredCycleModules(moduleGraph, module),
+					(mod) => chunkGraph.getModuleId(mod)
+				),
 				runtimeRequirements
 			)};\n`;
 
@@ -959,6 +1205,7 @@ class RuntimeTemplate {
 	}
 
 	/**
+	 * Export from import.
 	 * @template GenerateContext
 	 * @param {object} options options
 	 * @param {ModuleGraph} options.moduleGraph the module graph
@@ -976,6 +1223,7 @@ class RuntimeTemplate {
 	 * @param {RuntimeSpec} options.runtime runtime for which this code will be generated
 	 * @param {RuntimeRequirements} options.runtimeRequirements if set, will be filled with runtime requirements
 	 * @param {ModuleDependency} options.dependency module dependency
+	 * @param {boolean=} options.mangleableNamespace true, when a whole-namespace value may use a decoupled namespace object that keeps the original export names
 	 * @returns {string} expression
 	 */
 	exportFromImport({
@@ -993,7 +1241,8 @@ class RuntimeTemplate {
 		initFragments,
 		runtime,
 		runtimeRequirements,
-		dependency
+		dependency,
+		mangleableNamespace = false
 	}) {
 		if (!module) {
 			return this.missingModule({
@@ -1028,7 +1277,14 @@ class RuntimeTemplate {
 						);
 						return `${comment} undefined`;
 					}
-					const access = `${importVar}.a${propertyAccess(used)}`;
+					if (used instanceof InlinedUsedName) {
+						throw new Error(
+							"Can't inline the exports of defer imported module"
+						);
+					}
+					const access = `${importVar}.a${propertyAccess(
+						Array.isArray(used) ? used : [used]
+					)}`;
 					if (isCall || asiSafe === undefined) {
 						return access;
 					}
@@ -1086,7 +1342,7 @@ class RuntimeTemplate {
 				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
 				initFragments.push(
 					new InitFragment(
-						`var ${importVar}_namespace_cache;\n`,
+						`${this.renderLet()} ${importVar}_namespace_cache;\n`,
 						InitFragment.STAGE_CONSTANTS,
 						-1,
 						`${importVar}_namespace_cache`
@@ -1111,12 +1367,19 @@ class RuntimeTemplate {
 				);
 				return `${comment} undefined`;
 			}
+			if (used instanceof InlinedUsedName) {
+				return used.render(
+					Template.toNormalComment(
+						`inlined export ${propertyAccess(exportName)}`
+					)
+				);
+			}
 			const comment = equals(used, exportName)
 				? ""
 				: `${Template.toNormalComment(propertyAccess(exportName))} `;
 			const access = `${importVar}${
 				isModuleDeferred ? ".a" : ""
-			}${comment}${propertyAccess(used)}`;
+			}${comment}${propertyAccess(Array.isArray(used) ? used : [used])}`;
 			if (isCall && callContext === false) {
 				return asiSafe
 					? `(0,${access})`
@@ -1129,7 +1392,7 @@ class RuntimeTemplate {
 		if (isModuleDeferred) {
 			initFragments.push(
 				new InitFragment(
-					`var ${importVar}_deferred_namespace_cache;\n`,
+					`${this.renderLet()} ${importVar}_deferred_namespace_cache;\n`,
 					InitFragment.STAGE_CONSTANTS,
 					-1,
 					`${importVar}_deferred_namespace_cache`
@@ -1147,6 +1410,25 @@ class RuntimeTemplate {
 				asiSafe ? "" : asiSafe === false ? ";" : "Object"
 			}(${importVar}_deferred_namespace_cache || (${importVar}_deferred_namespace_cache = ${init}))`;
 		}
+		// The whole namespace object is used as a value. If the module's exports
+		// were mangled, importVar's keys are the mangled names, so we materialize
+		// a decoupled namespace object that exposes the original names.
+		if (
+			exportsType === "namespace" &&
+			mangleableNamespace &&
+			this.compilation &&
+			this.compilation.options.optimization.mangleExports
+		) {
+			const materialized = this._materializedNamespaceObject({
+				moduleGraph,
+				module,
+				importVar,
+				initFragments,
+				runtime,
+				runtimeRequirements
+			});
+			if (materialized !== undefined) return materialized;
+		}
 		// if we hit here, the importVar is either
 		// - already a ES module namespace object
 		// - or imported by a way that does not need interop.
@@ -1154,14 +1436,92 @@ class RuntimeTemplate {
 	}
 
 	/**
+	 * Materializes a namespace object that keeps the original export names while
+	 * the module's own exports are mangled. Returns undefined when no export was
+	 * mangled (then the raw namespace object can be used as-is).
+	 * @template GenerateContext
+	 * @param {object} options options
+	 * @param {ModuleGraph} options.moduleGraph the module graph
+	 * @param {Module} options.module the imported module
+	 * @param {string} options.importVar the import variable referencing the module
+	 * @param {InitFragment<GenerateContext>[]} options.initFragments target array for init fragments
+	 * @param {RuntimeSpec} options.runtime the runtime
+	 * @param {RuntimeRequirements} options.runtimeRequirements runtime requirements
+	 * @returns {string | undefined} expression of the materialized namespace object, or undefined
+	 */
+	_materializedNamespaceObject({
+		moduleGraph,
+		module,
+		importVar,
+		initFragments,
+		runtime,
+		runtimeRequirements
+	}) {
+		const exportsInfo = moduleGraph.getExportsInfo(module);
+		/** @type {string[]} */
+		const definitions = [];
+		let mangled = false;
+		for (const exportInfo of exportsInfo.orderedExports) {
+			if (exportInfo.provided === false) continue;
+			const used = exportsInfo.getUsedName([exportInfo.name], runtime);
+			if (!used) continue;
+			if (used instanceof InlinedUsedName) {
+				// An inlined export isn't reachable by name on the raw exports object,
+				// so the decoupled object must expose the inlined value directly.
+				mangled = true;
+				definitions.push(
+					`${propertyName(exportInfo.name)}: ${this.returningFunction(
+						used.render(
+							Template.toNormalComment(
+								`inlined export ${propertyAccess([exportInfo.name])}`
+							)
+						)
+					)}`
+				);
+				continue;
+			}
+			if (used[used.length - 1] !== exportInfo.name) mangled = true;
+			definitions.push(
+				`${propertyName(exportInfo.name)}: ${this.returningFunction(
+					`${importVar}${propertyAccess(/** @type {string[]} */ (used))}`
+				)}`
+			);
+		}
+		if (!mangled) return;
+		const name = `${importVar}_namespace_object`;
+		runtimeRequirements.add(RuntimeGlobals.exports);
+		runtimeRequirements.add(RuntimeGlobals.makeNamespaceObject);
+		runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
+		initFragments.push(
+			new InitFragment(
+				`var ${name} = {};\n${RuntimeGlobals.makeNamespaceObject}(${name});\n${
+					RuntimeGlobals.definePropertyGetters
+				}(${name}, {\n\t${definitions.join(",\n\t")}\n});\n`,
+				InitFragment.STAGE_PROVIDES,
+				0,
+				name
+			)
+		);
+		return name;
+	}
+
+	/**
+	 * Returns expression.
 	 * @param {object} options options
 	 * @param {AsyncDependenciesBlock | undefined} options.block the async block
 	 * @param {string} options.message the message
 	 * @param {ChunkGraph} options.chunkGraph the chunk graph
 	 * @param {RuntimeRequirements} options.runtimeRequirements if set, will be filled with runtime requirements
+	 * @param {Module=} options.originModule the module the `import()` is emitted into
 	 * @returns {string} expression
 	 */
-	blockPromise({ block, message, chunkGraph, runtimeRequirements }) {
+	blockPromise({
+		block,
+		message,
+		chunkGraph,
+		runtimeRequirements,
+		originModule
+	}) {
 		if (!block) {
 			const comment = this.comment({
 				message
@@ -1182,12 +1542,25 @@ class RuntimeTemplate {
 			message,
 			chunkName: block.chunkName
 		});
+		// A `fetchPriority` hint rides on the runtime `ensureChunk(id, priority)` call;
+		// the analyzable literal `import()` can't carry it, so keep the runtime form.
+		const fetchPriority = chunkGroup.options.fetchPriority;
 		if (chunks.length === 1) {
+			const analyzable = fetchPriority
+				? null
+				: this._analyzableChunkImport(
+						chunks[0],
+						comment,
+						runtimeRequirements,
+						originModule,
+						chunkGraph
+					);
+			if (analyzable !== null) {
+				return analyzable;
+			}
 			const chunkId = JSON.stringify(chunks[0].id);
 			runtimeRequirements.add(RuntimeGlobals.ensureChunk);
 
-			const fetchPriority = chunkGroup.options.fetchPriority;
-
 			if (fetchPriority) {
 				runtimeRequirements.add(RuntimeGlobals.hasFetchPriority);
 			}
@@ -1196,30 +1569,234 @@ class RuntimeTemplate {
 				fetchPriority ? `, ${JSON.stringify(fetchPriority)}` : ""
 			})`;
 		} else if (chunks.length > 0) {
-			runtimeRequirements.add(RuntimeGlobals.ensureChunk);
-
-			const fetchPriority = chunkGroup.options.fetchPriority;
-
 			if (fetchPriority) {
 				runtimeRequirements.add(RuntimeGlobals.hasFetchPriority);
 			}
 
+			let needEnsureChunk = false;
 			/**
+			 * Analyzable `import()` for a solely-owned JS chunk, else runtime ensureChunk.
 			 * @param {Chunk} chunk chunk
 			 * @returns {string} require chunk id code
 			 */
-			const requireChunkId = (chunk) =>
-				`${RuntimeGlobals.ensureChunk}(${JSON.stringify(chunk.id)}${
+			const requireChunkId = (chunk) => {
+				const analyzable = fetchPriority
+					? null
+					: this._analyzableChunkImport(
+							chunk,
+							"",
+							runtimeRequirements,
+							originModule,
+							chunkGraph
+						);
+				if (analyzable !== null) return analyzable;
+				needEnsureChunk = true;
+				return `${RuntimeGlobals.ensureChunk}(${JSON.stringify(chunk.id)}${
 					fetchPriority ? `, ${JSON.stringify(fetchPriority)}` : ""
 				})`;
-			return `Promise.all(${comment.trim()}[${chunks
-				.map(requireChunkId)
-				.join(", ")}])`;
+			};
+			const items = chunks.map(requireChunkId);
+			if (needEnsureChunk) {
+				runtimeRequirements.add(RuntimeGlobals.ensureChunk);
+			}
+			return `Promise.all(${comment.trim()}[${items.join(", ")}])`;
 		}
 		return `Promise.resolve(${comment.trim()})`;
 	}
 
 	/**
+	 * For ESM module output, load a single statically-named chunk through the
+	 * `analyzableChunkImport` helper — a literal `import("./chunk.js")` other bundlers
+	 * and webpack itself can follow, wrapped to keep `ensureChunk` timing and deduplication.
+	 * Returns `null` to fall back to the runtime `ensureChunk` form.
+	 * @param {Chunk} chunk the chunk to load
+	 * @param {string} comment leading comment (chunk name / message)
+	 * @param {RuntimeRequirements} runtimeRequirements runtime requirements
+	 * @param {Module=} originModule the module the `import()` is emitted into
+	 * @param {ChunkGraph=} chunkGraph the chunk graph
+	 * @returns {string | null} the import expression, or `null`
+	 */
+	_analyzableChunkImport(
+		chunk,
+		comment,
+		runtimeRequirements,
+		originModule,
+		chunkGraph
+	) {
+		const { outputOptions } = this;
+		if (
+			!outputOptions.module ||
+			outputOptions.chunkFormat !== "module" ||
+			outputOptions.importFunctionName !== "import" ||
+			chunk.id === null ||
+			!originModule ||
+			!chunkGraph
+		) {
+			return null;
+		}
+		// HMR wraps `ensureChunk` (`.e`) to track in-flight loads and relies on it being
+		// present in the runtime; the analyzable `import()` (`.ei`) replaces `.e` and would
+		// leave a lazy-compilation proxy's own `.e` call undefined, so keep the runtime form.
+		// A runtime `__webpack_public_path__` override likewise can't reach a baked literal.
+		if (
+			this.compilation.dependencyFactories.has(
+				getModuleHotAcceptDependency()
+			) ||
+			getAPIPlugin().usesRuntimePublicPathOverride(this.compilation)
+		) {
+			return null;
+		}
+		// A worker entry loads its own chunks through the worker runtime; keep that path.
+		for (const originChunk of chunkGraph.getModuleChunksIterable(
+			originModule
+		)) {
+			const entryOptions = originChunk.getEntryOptions();
+			if (entryOptions && entryOptions.worker) {
+				return null;
+			}
+		}
+		// Only a chunk that is loaded solely through this `import()` and holds pure JS:
+		// a shared chunk (splitChunks / module federation) or one with css/wasm/other
+		// assets needs the runtime's deduplication and per-type loaders, so keep it.
+		if (chunk.getNumberOfGroups() !== 1) {
+			return null;
+		}
+		// Prefetch/preload children (incl. CSS-only preload) are injected by the runtime
+		// `.f` handlers when the chunk loads, which the analyzable `import()` bypasses —
+		// keep the runtime form for them.
+		if (
+			chunk.hasChildByOrder(chunkGraph, "prefetch", true) ||
+			chunk.hasChildByOrder(chunkGraph, "preload", true) ||
+			chunk.hasChildByOrder(chunkGraph, "cssPreload", true)
+		) {
+			return null;
+		}
+		for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+			// Module federation (remote/shared/provide) loads through its own runtime.
+			if (FEDERATION_MODULE_TYPES.has(module.type)) {
+				return null;
+			}
+			for (const type of chunkGraph.getModuleSourceTypes(module)) {
+				if (type !== JAVASCRIPT_TYPE && type !== RUNTIME_TYPE) {
+					return null;
+				}
+			}
+		}
+		// Relative to the consuming chunk (`import.meta.url`) for `auto`, else an
+		// absolute publicPath prefix.
+		const specifier = this._getAnalyzableChunkSpecifier(
+			undefined,
+			chunk,
+			originModule,
+			chunkGraph
+		);
+		// `import()` needs a resolvable specifier — relative (`./`, `../`), absolute (`/`)
+		// or a URL scheme. A bare one (empty/relative publicPath) is treated as a package,
+		// so keep the runtime form. (`new URL(...)` callers accept bare, resolving vs base.)
+		if (
+			specifier === null ||
+			!/^"(?:\.{0,2}\/|[a-zA-Z][\w+.-]*:)/.test(specifier)
+		) {
+			return null;
+		}
+		runtimeRequirements.add(RuntimeGlobals.analyzableChunkImport);
+		// Drop-in for `ensureChunk(id)`: the literal `import()` can be statically
+		// followed, the helper keeps webpack's install timing and deduplication.
+		return `${RuntimeGlobals.analyzableChunkImport}(${JSON.stringify(
+			chunk.id
+		)}, () => import(${comment}${specifier}))`;
+	}
+
+	/**
+	 * Computes the `../`-path from the consuming module's chunk(s) back to the output
+	 * root, so a chunk or asset can be referenced relative to `import.meta.url`. Returns
+	 * `null` when the module lives in chunks of different depths (no single path works).
+	 * @param {Module} module the consuming module
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @returns {string | null} relative undo path, or `null` when ambiguous
+	 */
+	_getModuleUndoPath(module, chunkGraph) {
+		const { compilation } = this;
+		const { outputOptions } = compilation;
+		const outputPath = /** @type {string} */ (outputOptions.path);
+		/** @type {string | null} */
+		let result = null;
+		let found = false;
+		for (const chunk of chunkGraph.getModuleChunksIterable(module)) {
+			const template = getJavascriptModulesPlugin().getChunkFilenameTemplate(
+				chunk,
+				outputOptions
+			);
+			const chunkName = compilation.getPath(
+				// Hashes aren't known during code generation and only sit in the basename
+				// (never a directory), so neutralize them — only the `../` depth matters.
+				typeof template === "string"
+					? template.replace(HASH_IN_FILENAME_GLOBAL, "x")
+					: template,
+				{ chunk, contentHashType: JAVASCRIPT_TYPE }
+			);
+			const undo = getUndoPath(chunkName, outputPath, true);
+			if (!found) {
+				result = undo;
+				found = true;
+			} else if (result !== undo) {
+				return null;
+			}
+		}
+		return found ? result : null;
+	}
+
+	/**
+	 * Static literal specifier (already quoted) for a `new URL(<here>, import.meta.url)`
+	 * or `import(<here>)` pointing at `chunk`'s JS file, or `null` when it can't be known
+	 * statically — a content hash in the filename, or a dynamic/templated publicPath.
+	 * @param {string | undefined} overridePublicPath per-dependency public path (wins over `output.publicPath`)
+	 * @param {Chunk} chunk the chunk to reference
+	 * @param {Module} consumingModule the module the reference is emitted into
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @returns {string | null} a JS string literal, or `null` to fall back to the runtime form
+	 */
+	_getAnalyzableChunkSpecifier(
+		overridePublicPath,
+		chunk,
+		consumingModule,
+		chunkGraph
+	) {
+		const { compilation } = this;
+		const { outputOptions } = compilation;
+		const filenameTemplate =
+			getJavascriptModulesPlugin().getChunkFilenameTemplate(
+				chunk,
+				outputOptions
+			);
+		if (
+			typeof filenameTemplate !== "string" ||
+			HASH_IN_FILENAME.test(filenameTemplate)
+		) {
+			return null;
+		}
+		const filename = compilation.getPath(filenameTemplate, {
+			chunk,
+			contentHashType: JAVASCRIPT_TYPE
+		});
+		if (overridePublicPath) {
+			return overridePublicPath.includes("[")
+				? null
+				: toJsStringLiteral(overridePublicPath + filename);
+		}
+		const { publicPath } = outputOptions;
+		if (publicPath === "auto") {
+			const undo = this._getModuleUndoPath(consumingModule, chunkGraph);
+			return undo === null ? null : toJsStringLiteral(undo + filename);
+		}
+		if (typeof publicPath === "string" && !publicPath.includes("[")) {
+			return toJsStringLiteral(publicPath + filename);
+		}
+		return null;
+	}
+
+	/**
+	 * Async module factory.
 	 * @param {object} options options
 	 * @param {AsyncDependenciesBlock} options.block the async block
 	 * @param {ChunkGraph} options.chunkGraph the chunk graph
@@ -1252,6 +1829,7 @@ class RuntimeTemplate {
 	}
 
 	/**
+	 * Sync module factory.
 	 * @param {object} options options
 	 * @param {Dependency} options.dependency the dependency
 	 * @param {ChunkGraph} options.chunkGraph the chunk graph
@@ -1273,6 +1851,7 @@ class RuntimeTemplate {
 	}
 
 	/**
+	 * Define es module flag statement.
 	 * @param {object} options options
 	 * @param {string} options.exportsArgument the name of the exports object
 	 * @param {RuntimeRequirements} options.runtimeRequirements if set, will be filled with runtime requirements