webpack 5.97.1 → 5.104.1

package/lib/RuntimeTemplate.js

@@ -8,18 +8,31 @@
 const InitFragment = require("./InitFragment");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const Template = require("./Template");
+const {
+	getOutgoingAsyncModules
+} = require("./async-modules/AsyncModuleHelpers");
+const { ImportPhaseUtils } = require("./dependencies/ImportPhase");
+const {
+	getMakeDeferredNamespaceModeFromExportsType,
+	getOptimizedDeferredModule
+} = require("./runtime/MakeDeferredNamespaceObjectRuntime");
 const { equals } = require("./util/ArrayHelpers");
 const compileBooleanMatcher = require("./util/compileBooleanMatcher");
+const memoize = require("./util/memoize");
 const propertyAccess = require("./util/propertyAccess");
 const { forEachRuntime, subtractRuntime } = require("./util/runtime");
 
-/** @typedef {import("../declarations/WebpackOptions").Environment} Environment */
-/** @typedef {import("../declarations/WebpackOptions").OutputNormalized} OutputOptions */
+const getHarmonyImportDependency = memoize(() =>
+	require("./dependencies/HarmonyImportDependency")
+);
+const getImportDependency = memoize(() =>
+	require("./dependencies/ImportDependency")
+);
+
+/** @typedef {import("./config/defaults").OutputNormalizedWithDefaults} OutputOptions */
 /** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
 /** @typedef {import("./Chunk")} Chunk */
 /** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */
-/** @typedef {import("./CodeGenerationResults").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./Module")} Module */
@@ -28,6 +41,8 @@ const { forEachRuntime, subtractRuntime } = require("./util/runtime");
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./RequestShortener")} RequestShortener */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./dependencies/ImportPhase").ImportPhaseType} ImportPhaseType */
+/** @typedef {import("./NormalModuleFactory").ModuleDependency} ModuleDependency */
 
 /**
  * @param {Module} module the module
@@ -42,18 +57,16 @@ This should not happen.
 It's in these chunks: ${
 	Array.from(
 		chunkGraph.getModuleChunksIterable(module),
-		c => c.name || c.id || c.debugId
+		(c) => c.name || c.id || c.debugId
 	).join(", ") || "none"
 } (If module is in no chunk this indicates a bug in some chunk/module optimization logic)
 Module has these incoming connections: ${Array.from(
 	chunkGraph.moduleGraph.getIncomingConnections(module),
-	connection =>
+	(connection) =>
 		`\n - ${
 			connection.originModule && connection.originModule.identifier()
 		} ${connection.dependency && connection.dependency.type} ${
-			(connection.explanations &&
-				Array.from(connection.explanations).join(", ")) ||
-			""
+			(connection.explanations && [...connection.explanations].join(", ")) || ""
 		}`
 ).join("")}`;
 
@@ -72,8 +85,9 @@ function getGlobalObject(definition) {
 		// call expression
 		// expression in parentheses
 		/^([_\p{L}][_0-9\p{L}]*)?\(.*\)$/iu.test(trimmed)
-	)
+	) {
 		return trimmed;
+	}
 
 	return `Object(${trimmed})`;
 }
@@ -91,10 +105,7 @@ class RuntimeTemplate {
 		this.globalObject =
 			/** @type {string} */
 			(getGlobalObject(outputOptions.globalObject));
-		this.contentHashReplacement = "X".repeat(
-			/** @type {NonNullable<OutputOptions["hashDigestLength"]>} */
-			(outputOptions.hashDigestLength)
-		);
+		this.contentHashReplacement = "X".repeat(outputOptions.hashDigestLength);
 	}
 
 	isIIFE() {
@@ -107,7 +118,7 @@ class RuntimeTemplate {
 
 	isNeutralPlatform() {
 		return (
-			!this.outputOptions.environment.document &&
+			!this.compilation.compiler.platform.web &&
 			!this.compilation.compiler.platform.node
 		);
 	}
@@ -116,6 +127,10 @@ class RuntimeTemplate {
 		return this.outputOptions.environment.const;
 	}
 
+	supportsMethodShorthand() {
+		return this.outputOptions.environment.methodShorthand;
+	}
+
 	supportsArrowFunction() {
 		return this.outputOptions.environment.arrowFunction;
 	}
@@ -156,6 +171,23 @@ class RuntimeTemplate {
 		return this.outputOptions.environment.nodePrefixForCoreModules;
 	}
 
+	/**
+	 * @param {string} mod a module
+	 * @returns {string} a module with `node:` prefix when supported, otherwise an original name
+	 */
+	renderNodePrefixForCoreModule(mod) {
+		return this.outputOptions.environment.nodePrefixForCoreModules
+			? `"node:${mod}"`
+			: `"${mod}"`;
+	}
+
+	/**
+	 * @returns {"const" | "var"} return `const` when it is supported, otherwise `var`
+	 */
+	renderConst() {
+		return this.supportsConst() ? "const" : "var";
+	}
+
 	/**
 	 * @param {string} returnValue return value
 	 * @param {string} args arguments
@@ -179,7 +211,7 @@ class RuntimeTemplate {
 	}
 
 	/**
-	 * @param {Array<string|{expr: string}>} args args
+	 * @param {(string | { expr: string })[]} args args
 	 * @returns {string} result expression
 	 */
 	concatenation(...args) {
@@ -216,24 +248,25 @@ class RuntimeTemplate {
 			lastWasExpr = isExpr;
 		}
 		if (lastWasExpr) concatenationCost -= 3;
-		if (typeof args[0] !== "string" && typeof args[1] === "string")
+		if (typeof args[0] !== "string" && typeof args[1] === "string") {
 			concatenationCost -= 3;
+		}
 
 		if (concatenationCost <= templateCost) return this._es5Concatenation(args);
 
 		return `\`${args
-			.map(arg => (typeof arg === "string" ? arg : `\${${arg.expr}}`))
+			.map((arg) => (typeof arg === "string" ? arg : `\${${arg.expr}}`))
 			.join("")}\``;
 	}
 
 	/**
-	 * @param {Array<string|{expr: string}>} args args (len >= 2)
+	 * @param {(string | { expr: string })[]} args args (len >= 2)
 	 * @returns {string} result expression
 	 * @private
 	 */
 	_es5Concatenation(args) {
 		const str = args
-			.map(arg => (typeof arg === "string" ? JSON.stringify(arg) : arg.expr))
+			.map((arg) => (typeof arg === "string" ? JSON.stringify(arg) : arg.expr))
 			.join(" + ");
 
 		// when the first two args are expression, we need to prepend "" + to force string
@@ -283,7 +316,9 @@ class RuntimeTemplate {
 		return this.supportsDestructuring()
 			? `var {${items.join(", ")}} = ${value};`
 			: Template.asString(
-					items.map(item => `var ${item} = ${value}${propertyAccess([item])};`)
+					items.map(
+						(item) => `var ${item} = ${value}${propertyAccess([item])};`
+					)
 				);
 	}
 
@@ -325,12 +360,12 @@ class RuntimeTemplate {
 		if (this.outputOptions.pathinfo) {
 			content = [message, request, chunkName, chunkReason]
 				.filter(Boolean)
-				.map(item => this.requestShortener.shorten(item))
+				.map((item) => this.requestShortener.shorten(item))
 				.join(" | ");
 		} else {
 			content = [message, chunkName, chunkReason]
 				.filter(Boolean)
-				.map(item => this.requestShortener.shorten(item))
+				.map((item) => this.requestShortener.shorten(item))
 				.join(" | ");
 		}
 		if (!content) return "";
@@ -597,6 +632,7 @@ class RuntimeTemplate {
 	 * @param {string} options.message a message for the comment
 	 * @param {boolean=} options.strict if the current module is in strict esm mode
 	 * @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
 	 * @returns {string} the promise expression
 	 */
@@ -608,6 +644,7 @@ class RuntimeTemplate {
 		message,
 		strict,
 		weak,
+		dependency,
 		runtimeRequirements
 	}) {
 		if (!module) {
@@ -664,42 +701,45 @@ class RuntimeTemplate {
 				type: "statements"
 			})} } `;
 		}
-		const moduleIdExpr = this.moduleId({
-			module,
-			chunkGraph,
-			request,
-			weak
-		});
 		const exportsType = module.getExportsType(chunkGraph.moduleGraph, strict);
-		let fakeType = 16;
-		switch (exportsType) {
-			case "namespace":
+
+		const isModuleDeferred =
+			(dependency instanceof getHarmonyImportDependency() ||
+				dependency instanceof getImportDependency()) &&
+			ImportPhaseUtils.isDefer(dependency.phase) &&
+			!(/** @type {BuildMeta} */ (module.buildMeta).async);
+
+		if (isModuleDeferred) {
+			runtimeRequirements.add(RuntimeGlobals.makeDeferredNamespaceObject);
+			const mode = getMakeDeferredNamespaceModeFromExportsType(exportsType);
+			const asyncDeps = Array.from(
+				getOutgoingAsyncModules(chunkGraph.moduleGraph, module),
+				(m) => chunkGraph.getModuleId(m)
+			).filter((id) => id !== null);
+			if (asyncDeps.length) {
 				if (header) {
-					const rawModule = this.moduleRaw({
-						module,
-						chunkGraph,
-						request,
-						weak,
-						runtimeRequirements
-					});
 					appending = `.then(${this.basicFunction(
 						"",
-						`${header}return ${rawModule};`
+						`${header}return ${RuntimeGlobals.deferredModuleAsyncTransitiveDependencies}(${JSON.stringify(asyncDeps)});`
 					)})`;
 				} else {
 					runtimeRequirements.add(RuntimeGlobals.require);
-					appending = `.then(${RuntimeGlobals.require}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}))`;
+					appending = `.then(${this.returningFunction(`${RuntimeGlobals.deferredModuleAsyncTransitiveDependencies}(${JSON.stringify(asyncDeps)})`)})`;
 				}
-				break;
-			case "dynamic":
-				fakeType |= 4;
-			/* fall through */
-			case "default-with-named":
-				fakeType |= 2;
-			/* fall through */
-			case "default-only":
-				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
-				if (chunkGraph.moduleGraph.isAsync(module)) {
+				appending += `.then(${RuntimeGlobals.makeDeferredNamespaceObject}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}, ${mode}))`;
+			} else if (header) {
+				appending = `.then(${this.basicFunction(
+					"",
+					`${header}return ${RuntimeGlobals.makeDeferredNamespaceObject}(${comment}${idExpr}, ${mode});`
+				)})`;
+			} else {
+				runtimeRequirements.add(RuntimeGlobals.require);
+				appending = `.then(${RuntimeGlobals.makeDeferredNamespaceObject}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}, ${mode}))`;
+			}
+		} else {
+			let fakeType = 16;
+			switch (exportsType) {
+				case "namespace":
 					if (header) {
 						const rawModule = this.moduleRaw({
 							module,
@@ -716,23 +756,56 @@ class RuntimeTemplate {
 						runtimeRequirements.add(RuntimeGlobals.require);
 						appending = `.then(${RuntimeGlobals.require}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}))`;
 					}
-					appending += `.then(${this.returningFunction(
-						`${RuntimeGlobals.createFakeNamespaceObject}(m, ${fakeType})`,
-						"m"
-					)})`;
-				} else {
-					fakeType |= 1;
-					if (header) {
-						const returnExpression = `${RuntimeGlobals.createFakeNamespaceObject}(${moduleIdExpr}, ${fakeType})`;
-						appending = `.then(${this.basicFunction(
-							"",
-							`${header}return ${returnExpression};`
+					break;
+				case "dynamic":
+					fakeType |= 4;
+				/* fall through */
+				case "default-with-named":
+					fakeType |= 2;
+				/* fall through */
+				case "default-only":
+					runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
+					if (chunkGraph.moduleGraph.isAsync(module)) {
+						if (header) {
+							const rawModule = this.moduleRaw({
+								module,
+								chunkGraph,
+								request,
+								weak,
+								runtimeRequirements
+							});
+							appending = `.then(${this.basicFunction(
+								"",
+								`${header}return ${rawModule};`
+							)})`;
+						} else {
+							runtimeRequirements.add(RuntimeGlobals.require);
+							appending = `.then(${RuntimeGlobals.require}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}))`;
+						}
+						appending += `.then(${this.returningFunction(
+							`${RuntimeGlobals.createFakeNamespaceObject}(m, ${fakeType})`,
+							"m"
 						)})`;
 					} else {
-						appending = `.then(${RuntimeGlobals.createFakeNamespaceObject}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}, ${fakeType}))`;
+						fakeType |= 1;
+						if (header) {
+							const moduleIdExpr = this.moduleId({
+								module,
+								chunkGraph,
+								request,
+								weak
+							});
+							const returnExpression = `${RuntimeGlobals.createFakeNamespaceObject}(${moduleIdExpr}, ${fakeType})`;
+							appending = `.then(${this.basicFunction(
+								"",
+								`${header}return ${returnExpression};`
+							)})`;
+						} else {
+							appending = `.then(${RuntimeGlobals.createFakeNamespaceObject}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}, ${fakeType}))`;
+						}
 					}
-				}
-				break;
+					break;
+			}
 		}
 
 		return `${promise || "Promise.resolve()"}${appending}`;
@@ -756,22 +829,22 @@ class RuntimeTemplate {
 		if (typeof runtimeCondition === "boolean") return `${runtimeCondition}`;
 		/** @type {Set<string>} */
 		const positiveRuntimeIds = new Set();
-		forEachRuntime(runtimeCondition, runtime =>
+		forEachRuntime(runtimeCondition, (runtime) =>
 			positiveRuntimeIds.add(
 				`${chunkGraph.getRuntimeId(/** @type {string} */ (runtime))}`
 			)
 		);
 		/** @type {Set<string>} */
 		const negativeRuntimeIds = new Set();
-		forEachRuntime(subtractRuntime(runtime, runtimeCondition), runtime =>
+		forEachRuntime(subtractRuntime(runtime, runtimeCondition), (runtime) =>
 			negativeRuntimeIds.add(
 				`${chunkGraph.getRuntimeId(/** @type {string} */ (runtime))}`
 			)
 		);
 		runtimeRequirements.add(RuntimeGlobals.runtimeId);
 		return compileBooleanMatcher.fromLists(
-			Array.from(positiveRuntimeIds),
-			Array.from(negativeRuntimeIds)
+			[...positiveRuntimeIds],
+			[...negativeRuntimeIds]
 		)(RuntimeGlobals.runtimeId);
 	}
 
@@ -779,22 +852,26 @@ class RuntimeTemplate {
 	 * @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
+	 * @param {ModuleGraph} options.moduleGraph the module graph
 	 * @param {ChunkGraph} options.chunkGraph the chunk graph
 	 * @param {string} options.request the request that should be printed as comment
 	 * @param {string} options.importVar name of the import variable
 	 * @param {Module} options.originModule module in which the statement is emitted
 	 * @param {boolean=} options.weak true, if this is a weak dependency
 	 * @param {RuntimeRequirements} options.runtimeRequirements if set, will be filled with runtime requirements
+	 * @param {ModuleDependency} options.dependency module dependency
 	 * @returns {[string, string]} the import statement and the compat statement
 	 */
 	importStatement({
 		update,
 		module,
+		moduleGraph,
 		chunkGraph,
 		request,
 		importVar,
 		originModule,
 		weak,
+		dependency,
 		runtimeRequirements
 	}) {
 		if (!module) {
@@ -805,6 +882,7 @@ class RuntimeTemplate {
 				""
 			];
 		}
+
 		if (chunkGraph.getModuleId(module) === null) {
 			if (weak) {
 				// only weak referenced modules don't get an id
@@ -840,7 +918,28 @@ class RuntimeTemplate {
 			(originModule.buildMeta).strictHarmonyModule
 		);
 		runtimeRequirements.add(RuntimeGlobals.require);
-		const importContent = `/* harmony import */ ${optDeclaration}${importVar} = ${RuntimeGlobals.require}(${moduleId});\n`;
+		let importContent;
+
+		const isModuleDeferred =
+			(dependency instanceof getHarmonyImportDependency() ||
+				dependency instanceof getImportDependency()) &&
+			ImportPhaseUtils.isDefer(dependency.phase) &&
+			!(/** @type {BuildMeta} */ (module.buildMeta).async);
+
+		if (isModuleDeferred) {
+			/** @type {Set<Module>} */
+			const outgoingAsyncModules = getOutgoingAsyncModules(moduleGraph, module);
+
+			importContent = `/* deferred harmony import */ ${optDeclaration}${importVar} = ${getOptimizedDeferredModule(
+				moduleId,
+				exportsType,
+				Array.from(outgoingAsyncModules, (mod) => chunkGraph.getModuleId(mod)),
+				runtimeRequirements
+			)};\n`;
+
+			return [importContent, ""];
+		}
+		importContent = `/* harmony import */ ${optDeclaration}${importVar} = ${RuntimeGlobals.require}(${moduleId});\n`;
 
 		if (exportsType === "dynamic") {
 			runtimeRequirements.add(RuntimeGlobals.compatGetDefaultExport);
@@ -853,24 +952,28 @@ class RuntimeTemplate {
 	}
 
 	/**
+	 * @template GenerateContext
 	 * @param {object} options options
 	 * @param {ModuleGraph} options.moduleGraph the module graph
+	 * @param {ChunkGraph} options.chunkGraph the chunk graph
 	 * @param {Module} options.module the module
 	 * @param {string} options.request the request
 	 * @param {string | string[]} options.exportName the export name
 	 * @param {Module} options.originModule the origin module
-	 * @param {boolean|undefined} options.asiSafe true, if location is safe for ASI, a bracket can be emitted
+	 * @param {boolean | undefined} options.asiSafe true, if location is safe for ASI, a bracket can be emitted
 	 * @param {boolean} options.isCall true, if expression will be called
 	 * @param {boolean | null} options.callContext when false, call context will not be preserved
 	 * @param {boolean} options.defaultInterop when true and accessing the default exports, interop code will be generated
 	 * @param {string} options.importVar the identifier name of the import variable
-	 * @param {InitFragment<TODO>[]} options.initFragments init fragments will be added here
+	 * @param {InitFragment<GenerateContext>[]} options.initFragments init fragments will be added here
 	 * @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
 	 * @returns {string} expression
 	 */
 	exportFromImport({
 		moduleGraph,
+		chunkGraph,
 		module,
 		request,
 		exportName,
@@ -882,7 +985,8 @@ class RuntimeTemplate {
 		importVar,
 		initFragments,
 		runtime,
-		runtimeRequirements
+		runtimeRequirements,
+		dependency
 	}) {
 		if (!module) {
 			return this.missingModule({
@@ -898,8 +1002,37 @@ class RuntimeTemplate {
 			(originModule.buildMeta).strictHarmonyModule
 		);
 
+		const isModuleDeferred =
+			(dependency instanceof getHarmonyImportDependency() ||
+				dependency instanceof getImportDependency()) &&
+			ImportPhaseUtils.isDefer(dependency.phase) &&
+			!(/** @type {BuildMeta} */ (module.buildMeta).async);
+
 		if (defaultInterop) {
+			// when the defaultInterop is used (when a ESM imports a CJS module),
 			if (exportName.length > 0 && exportName[0] === "default") {
+				if (isModuleDeferred && exportsType !== "namespace") {
+					const exportsInfo = moduleGraph.getExportsInfo(module);
+					const name = exportName.slice(1);
+					const used = exportsInfo.getUsedName(name, runtime);
+					if (!used) {
+						const comment = Template.toNormalComment(
+							`unused export ${propertyAccess(exportName)}`
+						);
+						return `${comment} undefined`;
+					}
+					const access = `${importVar}.a${propertyAccess(used)}`;
+					if (isCall || asiSafe === undefined) {
+						return access;
+					}
+					return asiSafe ? `(${access})` : `;(${access})`;
+				}
+				// accessing the .default property is same thing as `require()` the module.
+
+				// For example:
+				// import mod from "cjs";    mod.default.x;
+				// is translated to
+				// var mod = require("cjs"); mod.x;
 				switch (exportsType) {
 					case "dynamic":
 						if (isCall) {
@@ -917,7 +1050,11 @@ class RuntimeTemplate {
 						break;
 				}
 			} else if (exportName.length > 0) {
+				// the property used is not .default.
+				// For example:
+				// import * as ns from "cjs"; cjs.prop;
 				if (exportsType === "default-only") {
+					// in the strictest case, it is a runtime error (e.g. NodeJS behavior of CJS-ESM interop).
 					return `/* non-default import from non-esm module */undefined${propertyAccess(
 						exportName,
 						1
@@ -928,10 +1065,17 @@ class RuntimeTemplate {
 				) {
 					return "/* __esModule */true";
 				}
+			} else if (isModuleDeferred) {
+				// now exportName.length is 0
+				// fall through to the end of this function, create the namespace there.
 			} else if (
 				exportsType === "default-only" ||
 				exportsType === "default-with-named"
 			) {
+				// now exportName.length is 0, which means the namespace object is used in an unknown way
+				// for example:
+				// import * as ns from "cjs"; console.log(ns);
+				// we will need to createFakeNamespaceObject that simulates ES Module namespace object
 				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
 				initFragments.push(
 					new InitFragment(
@@ -951,6 +1095,8 @@ class RuntimeTemplate {
 
 		if (exportName.length > 0) {
 			const exportsInfo = moduleGraph.getExportsInfo(module);
+			// in some case the exported item is renamed (get this by getUsedName). for example,
+			// x.default might be emitted as x.Z (default is renamed to Z)
 			const used = exportsInfo.getUsedName(exportName, runtime);
 			if (!used) {
 				const comment = Template.toNormalComment(
@@ -961,7 +1107,9 @@ class RuntimeTemplate {
 			const comment = equals(used, exportName)
 				? ""
 				: `${Template.toNormalComment(propertyAccess(exportName))} `;
-			const access = `${importVar}${comment}${propertyAccess(used)}`;
+			const access = `${importVar}${
+				isModuleDeferred ? ".a" : ""
+			}${comment}${propertyAccess(used)}`;
 			if (isCall && callContext === false) {
 				return asiSafe
 					? `(0,${access})`
@@ -971,6 +1119,30 @@ class RuntimeTemplate {
 			}
 			return access;
 		}
+		if (isModuleDeferred) {
+			initFragments.push(
+				new InitFragment(
+					`var ${importVar}_deferred_namespace_cache;\n`,
+					InitFragment.STAGE_CONSTANTS,
+					-1,
+					`${importVar}_deferred_namespace_cache`
+				)
+			);
+
+			runtimeRequirements.add(RuntimeGlobals.makeDeferredNamespaceObject);
+			const id = chunkGraph.getModuleId(module);
+			const type = getMakeDeferredNamespaceModeFromExportsType(exportsType);
+			const init = `${
+				RuntimeGlobals.makeDeferredNamespaceObject
+			}(${JSON.stringify(id)}, ${type})`;
+
+			return `/*#__PURE__*/ ${
+				asiSafe ? "" : asiSafe === false ? ";" : "Object"
+			}(${importVar}_deferred_namespace_cache || (${importVar}_deferred_namespace_cache = ${init}))`;
+		}
+		// if we hit here, the importVar is either
+		// - already a ES module namespace object
+		// - or imported by a way that does not need interop.
 		return importVar;
 	}
 
@@ -997,7 +1169,7 @@ class RuntimeTemplate {
 			return `Promise.resolve(${comment.trim()})`;
 		}
 		const chunks = chunkGroup.chunks.filter(
-			chunk => !chunk.hasRuntime() && chunk.id !== null
+			(chunk) => !chunk.hasRuntime() && chunk.id !== null
 		);
 		const comment = this.comment({
 			message,
@@ -1029,7 +1201,7 @@ class RuntimeTemplate {
 			 * @param {Chunk} chunk chunk
 			 * @returns {string} require chunk id code
 			 */
-			const requireChunkId = chunk =>
+			const requireChunkId = (chunk) =>
 				`${RuntimeGlobals.ensureChunk}(${JSON.stringify(chunk.id)}${
 					fetchPriority ? `, ${JSON.stringify(fetchPriority)}` : ""
 				})`;

package/lib/SelfModuleFactory.js

@@ -5,8 +5,8 @@
 
 "use strict";
 
+/** @typedef {import("./ModuleFactory").ModuleFactoryCallback} ModuleFactoryCallback */
 /** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 
 class SelfModuleFactory {
@@ -19,7 +19,7 @@ class SelfModuleFactory {
 
 	/**
 	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function((Error | null)=, ModuleFactoryResult=): void} callback callback
+	 * @param {ModuleFactoryCallback} callback callback
 	 * @returns {void}
 	 */
 	create(data, callback) {

package/lib/SizeFormatHelpers.js

@@ -6,10 +6,10 @@
 "use strict";
 
 /**
- * @param {number} size the size in bytes
+ * @param {number=} size the size in bytes
  * @returns {string} the formatted size
  */
-module.exports.formatSize = size => {
+module.exports.formatSize = (size) => {
 	if (typeof size !== "number" || Number.isNaN(size) === true) {
 		return "unknown size";
 	}