webpack 5.101.2 → 5.102.0

package/lib/ExportsInfo.js

@@ -12,6 +12,8 @@ const { forEachRuntime } = require("./util/runtime");
 
 /** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./Dependency").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./Dependency").ExportsSpecExcludeExports} ExportsSpecExcludeExports */
+/** @typedef {import("./dependencies/HarmonyImportDependency")} HarmonyImportDependency */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./ModuleGraphConnection")} ModuleGraphConnection */
@@ -22,17 +24,22 @@ const { forEachRuntime } = require("./util/runtime");
 /** @typedef {typeof UsageState.OnlyPropertiesUsed | typeof UsageState.NoInfo | typeof UsageState.Unknown | typeof UsageState.Used} RuntimeUsageStateType */
 /** @typedef {typeof UsageState.Unused | RuntimeUsageStateType} UsageStateType */
 
-const UsageState = Object.freeze({
-	Unused: /** @type {0} */ (0),
-	OnlyPropertiesUsed: /** @type {1} */ (1),
-	NoInfo: /** @type {2} */ (2),
-	Unknown: /** @type {3} */ (3),
-	Used: /** @type {4} */ (4)
-});
+/** @typedef {string} ExportInfoName */
 
-const RETURNS_TRUE = () => true;
+/** @typedef {Map<string, RuntimeUsageStateType>} UsedInRuntime */
+/** @typedef {{ module: Module, export: ExportInfoName[], deferred: boolean }} TargetItemWithoutConnection */
+/** @typedef {{ module: Module, connection: ModuleGraphConnection, export: ExportInfoName[] | undefined }} TargetItemWithConnection */
+/** @typedef {(target: TargetItemWithConnection) => boolean} ResolveTargetFilter */
+/** @typedef {(module: Module) => boolean} ValidTargetModuleFilter */
+/** @typedef {{ connection: ModuleGraphConnection, export: ExportInfoName[], priority: number }} TargetItem */
+/** @typedef {Map<Dependency | undefined, TargetItem>} Target */
 
-const CIRCULAR = Symbol("circular target");
+/** @typedef {string | null} ExportInfoUsedName */
+/** @typedef {boolean | null} ExportInfoProvided */
+
+/** @typedef {Map<ExportInfoName, ExportInfo>} Exports */
+/** @typedef {string | string[] | false} UsedName */
+/** @typedef {Set<ExportInfo>} AlreadyVisitedExportInfo */
 
 /**
  * @typedef {object} RestoreProvidedDataExports
@@ -43,6 +50,18 @@ const CIRCULAR = Symbol("circular target");
  * @property {RestoreProvidedData | undefined} exportsInfo
  */
 
+const UsageState = Object.freeze({
+	Unused: /** @type {0} */ (0),
+	OnlyPropertiesUsed: /** @type {1} */ (1),
+	NoInfo: /** @type {2} */ (2),
+	Unknown: /** @type {3} */ (3),
+	Used: /** @type {4} */ (4)
+});
+
+const RETURNS_TRUE = () => true;
+
+const CIRCULAR = Symbol("circular target");
+
 class RestoreProvidedData {
 	/**
 	 * @param {RestoreProvidedDataExports[]} exports exports
@@ -87,14 +106,11 @@ makeSerializable(
 	"RestoreProvidedData"
 );
 
-/** @typedef {Map<ExportInfoName, ExportInfo>} Exports */
-/** @typedef {string | string[] | false} UsedName */
-
 class ExportsInfo {
 	constructor() {
 		/** @type {Exports} */
 		this._exports = new Map();
-		this._otherExportsInfo = new ExportInfo(/** @type {TODO} */ (null));
+		this._otherExportsInfo = new ExportInfo(null);
 		this._sideEffectsOnlyInfo = new ExportInfo("*side effects only*");
 		this._exportsAreOrdered = false;
 		/** @type {ExportsInfo=} */
@@ -171,7 +187,7 @@ class ExportsInfo {
 	 */
 	_sortExportsMap(exports) {
 		if (exports.size > 1) {
-			/** @type {string[]} */
+			/** @type {ExportInfoName[]} */
 			const namesInOrder = [];
 			for (const entry of exports.values()) {
 				namesInOrder.push(entry.name);
@@ -308,7 +324,7 @@ class ExportsInfo {
 
 	/**
 	 * @param {boolean=} canMangle true, if exports can still be mangled (defaults to false)
-	 * @param {Set<string>=} excludeExports list of unaffected exports
+	 * @param {ExportsSpecExcludeExports=} excludeExports list of unaffected exports
 	 * @param {Dependency=} targetKey use this as key for the target
 	 * @param {ModuleGraphConnection=} targetModule set this module as target
 	 * @param {number=} priority priority
@@ -505,7 +521,7 @@ class ExportsInfo {
 
 	/**
 	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {SortableSet<string> | boolean | null} set of used exports, or true (when namespace object is used), or false (when unused), or null (when unknown)
+	 * @returns {SortableSet<ExportInfoName> | boolean | null} set of used exports, or true (when namespace object is used), or false (when unused), or null (when unknown)
 	 */
 	getUsedExports(runtime) {
 		switch (this._otherExportsInfo.getUsed(runtime)) {
@@ -517,6 +533,7 @@ class ExportsInfo {
 				return true;
 		}
 
+		/** @type {ExportInfoName[]} */
 		const array = [];
 		if (!this._exportsAreOrdered) this._sortExports();
 		for (const exportInfo of this._exports.values()) {
@@ -548,11 +565,11 @@ class ExportsInfo {
 					return false;
 			}
 		}
-		return /** @type {SortableSet<string>} */ (new SortableSet(array));
+		return /** @type {SortableSet<ExportInfoName>} */ (new SortableSet(array));
 	}
 
 	/**
-	 * @returns {null | true | string[]} list of exports when known
+	 * @returns {null | true | ExportInfoName[]} list of exports when known
 	 */
 	getProvidedExports() {
 		switch (this._otherExportsInfo.provided) {
@@ -564,7 +581,7 @@ class ExportsInfo {
 				return true;
 		}
 
-		/** @type {string[]} */
+		/** @type {ExportInfoName[]} */
 		const array = [];
 		if (!this._exportsAreOrdered) this._sortExports();
 		for (const exportInfo of this._exports.values()) {
@@ -831,32 +848,14 @@ class ExportsInfo {
 	}
 }
 
-/** @typedef {Map<string, RuntimeUsageStateType>} UsedInRuntime */
-
-/** @typedef {{ module: Module, export: string[], deferred: boolean }} TargetItemWithoutConnection */
-
-/** @typedef {{ module: Module, connection: ModuleGraphConnection, export: string[] | undefined }} TargetItemWithConnection */
-
-/** @typedef {(target: TargetItemWithConnection) => boolean} ResolveTargetFilter */
-
-/** @typedef {(module: Module) => boolean} ValidTargetModuleFilter */
-
-/** @typedef {{ connection: ModuleGraphConnection, export: string[], priority: number }} TargetItem */
-
-/** @typedef {Map<Dependency | undefined, TargetItem>} Target */
-
-/** @typedef {string} ExportInfoName */
-/** @typedef {string | null} ExportInfoUsedName */
-/** @typedef {boolean | null} ExportInfoProvided */
-
 class ExportInfo {
 	/**
-	 * @param {ExportInfoName} name the original name of the export
+	 * @param {ExportInfoName | null} name the original name of the export
 	 * @param {ExportInfo=} initFrom init values from this ExportInfo
 	 */
 	constructor(name, initFrom) {
 		/** @type {ExportInfoName} */
-		this.name = name;
+		this.name = /** @type {ExportInfoName} */ (name);
 		/**
 		 * @private
 		 * @type {ExportInfoUsedName}
@@ -1058,8 +1057,8 @@ class ExportInfo {
 			}
 		} else {
 			let changed = false;
-			forEachRuntime(runtime, (_runtime) => {
-				const runtime = /** @type {string} */ (_runtime);
+			forEachRuntime(runtime, (runtime_) => {
+				const runtime = /** @type {string} */ (runtime_);
 				const usedInRuntime =
 					/** @type {UsedInRuntime} */
 					(this._usedInRuntime);
@@ -1148,7 +1147,7 @@ class ExportInfo {
 	/**
 	 * @param {Dependency} key the key
 	 * @param {ModuleGraphConnection} connection the target module if a single one
-	 * @param {(string[] | null)=} exportName the exported name
+	 * @param {ExportInfoName[] | null=} exportName the exported name
 	 * @param {number=} priority priority
 	 * @returns {boolean} true, if something has changed
 	 */
@@ -1158,7 +1157,7 @@ class ExportInfo {
 			this._target = new Map();
 			this._target.set(key, {
 				connection,
-				export: /** @type {string[]} */ (exportName),
+				export: /** @type {ExportInfoName[]} */ (exportName),
 				priority
 			});
 			return true;
@@ -1168,7 +1167,7 @@ class ExportInfo {
 			if (oldTarget === null && !connection) return false;
 			this._target.set(key, {
 				connection,
-				export: /** @type {string[]} */ (exportName),
+				export: /** @type {ExportInfoName[]} */ (exportName),
 				priority
 			});
 			this._maxTarget = undefined;
@@ -1182,7 +1181,7 @@ class ExportInfo {
 				: oldTarget.export)
 		) {
 			oldTarget.connection = connection;
-			oldTarget.export = /** @type {string[]} */ (exportName);
+			oldTarget.export = /** @type {ExportInfoName[]} */ (exportName);
 			oldTarget.priority = priority;
 			this._maxTarget = undefined;
 			return true;
@@ -1331,7 +1330,7 @@ class ExportInfo {
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @param {ValidTargetModuleFilter} validTargetModuleFilter a valid target module
-	 * @param {Set<ExportInfo>} alreadyVisited set of already visited export info to avoid circular references
+	 * @param {AlreadyVisitedExportInfo} alreadyVisited set of already visited export info to avoid circular references
 	 * @returns {TargetItemWithoutConnection | null | undefined | false} the target, undefined when there is no target, false when no target is valid
 	 */
 	_findTarget(moduleGraph, validTargetModuleFilter, alreadyVisited) {
@@ -1345,7 +1344,9 @@ class ExportInfo {
 			module: rawTarget.connection.module,
 			export: rawTarget.export,
 			deferred: Boolean(
-				rawTarget.connection.dependency && rawTarget.connection.dependency.defer
+				rawTarget.connection.dependency &&
+					/** @type {HarmonyImportDependency} */
+					(rawTarget.connection.dependency).defer
 			)
 		};
 		for (;;) {
@@ -1387,13 +1388,13 @@ class ExportInfo {
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @param {ResolveTargetFilter} resolveTargetFilter filter function to further resolve target
-	 * @param {Set<ExportInfo> | undefined} alreadyVisited set of already visited export info to avoid circular references
+	 * @param {AlreadyVisitedExportInfo | undefined} alreadyVisited set of already visited export info to avoid circular references
 	 * @returns {TargetItemWithConnection | CIRCULAR | undefined} the target
 	 */
 	_getTarget(moduleGraph, resolveTargetFilter, alreadyVisited) {
 		/**
 		 * @param {TargetItem | undefined | null} inputTarget unresolved target
-		 * @param {Set<ExportInfo>} alreadyVisited set of already visited export info to avoid circular references
+		 * @param {AlreadyVisitedExportInfo} alreadyVisited set of already visited export info to avoid circular references
 		 * @returns {TargetItemWithConnection | CIRCULAR | null} resolved target
 		 */
 		const resolveTarget = (inputTarget, alreadyVisited) => {

package/lib/ExternalModule.js

@@ -29,22 +29,23 @@ const { register } = require("./util/serialization");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../declarations/WebpackOptions").HashFunction} HashFunction */
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
 /** @typedef {import("./Chunk")} Chunk */
 /** @typedef {import("./ChunkGraph")} ChunkGraph */
 /** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./Compilation").UnsafeCacheData} UnsafeCacheData */
 /** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("./ExportsInfo")} ExportsInfo */
 /** @typedef {import("./Generator").GenerateContext} GenerateContext */
 /** @typedef {import("./Generator").SourceTypes} SourceTypes */
+/** @typedef {import("./Module").ModuleId} ModuleId */
 /** @typedef {import("./Module").BuildCallback} BuildCallback */
 /** @typedef {import("./Module").BuildInfo} BuildInfo */
 /** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
 /** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("./Module").LibIdent} LibIdent */
 /** @typedef {import("./Module").NeedBuildCallback} NeedBuildCallback */
 /** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
 /** @typedef {import("./Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
@@ -53,7 +54,6 @@ const { register } = require("./util/serialization");
 /** @typedef {import("./RequestShortener")} RequestShortener */
 /** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./WebpackError")} WebpackError */
 /** @typedef {import("./javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
 /** @typedef {import("./javascript/JavascriptParser").ImportAttributes} ImportAttributes */
 /** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
@@ -88,7 +88,7 @@ const RUNTIME_REQUIREMENTS_FOR_MODULE = new Set([
 const EMPTY_RUNTIME_REQUIREMENTS = new Set([]);
 
 /**
- * @param {string|string[]} variableName the variable name or path
+ * @param {string | string[]} variableName the variable name or path
  * @param {string} type the module system
  * @returns {SourceData} the generated source
  */
@@ -108,8 +108,10 @@ const getSourceForGlobalVariableExternal = (variableName, type) => {
 	};
 };
 
+/** @typedef {string | string[]} ModuleAndSpecifiers */
+
 /**
- * @param {string|string[]} moduleAndSpecifiers the module request
+ * @param {ModuleAndSpecifiers} moduleAndSpecifiers the module request
  * @returns {SourceData} the generated source
  */
 const getSourceForCommonJsExternal = (moduleAndSpecifiers) => {
@@ -128,7 +130,24 @@ const getSourceForCommonJsExternal = (moduleAndSpecifiers) => {
 };
 
 /**
- * @param {string | string[]} moduleAndSpecifiers the module request
+ * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @returns {InitFragment<ChunkRenderContext>} code
+ */
+const getExternalModuleNodeCommonjsInitFragment = (runtimeTemplate) => {
+	const importMetaName = runtimeTemplate.outputOptions.importMetaName;
+
+	return new InitFragment(
+		`import { createRequire as __WEBPACK_EXTERNAL_createRequire } from ${runtimeTemplate.renderNodePrefixForCoreModule(
+			"module"
+		)};\n${runtimeTemplate.renderConst()} __WEBPACK_EXTERNAL_createRequire_require = __WEBPACK_EXTERNAL_createRequire(${importMetaName}.url);\n`,
+		InitFragment.STAGE_HARMONY_IMPORTS,
+		0,
+		"external module node-commonjs"
+	);
+};
+
+/**
+ * @param {ModuleAndSpecifiers} moduleAndSpecifiers the module request
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
  * @returns {SourceData} the generated source
  */
@@ -136,25 +155,13 @@ const getSourceForCommonJsExternalInNodeModule = (
 	moduleAndSpecifiers,
 	runtimeTemplate
 ) => {
-	const importMetaName =
-		/** @type {string} */
-		(runtimeTemplate.outputOptions.importMetaName);
-
-	// 	/** @type {boolean} */
-	// 	(runtimeTemplate.supportNodePrefixForCoreModules())
-
 	const chunkInitFragments = [
-		new InitFragment(
-			`import { createRequire as __WEBPACK_EXTERNAL_createRequire } from ${runtimeTemplate.renderNodePrefixForCoreModule("module")};\n`,
-			InitFragment.STAGE_HARMONY_IMPORTS,
-			0,
-			"external module node-commonjs"
-		)
+		getExternalModuleNodeCommonjsInitFragment(runtimeTemplate)
 	];
 	if (!Array.isArray(moduleAndSpecifiers)) {
 		return {
 			chunkInitFragments,
-			expression: `__WEBPACK_EXTERNAL_createRequire(${importMetaName}.url)(${JSON.stringify(
+			expression: `__WEBPACK_EXTERNAL_createRequire_require(${JSON.stringify(
 				moduleAndSpecifiers
 			)})`
 		};
@@ -162,14 +169,14 @@ const getSourceForCommonJsExternalInNodeModule = (
 	const moduleName = moduleAndSpecifiers[0];
 	return {
 		chunkInitFragments,
-		expression: `__WEBPACK_EXTERNAL_createRequire(${importMetaName}.url)(${JSON.stringify(
+		expression: `__WEBPACK_EXTERNAL_createRequire_require(${JSON.stringify(
 			moduleName
 		)})${propertyAccess(moduleAndSpecifiers, 1)}`
 	};
 };
 
 /**
- * @param {string|string[]} moduleAndSpecifiers the module request
+ * @param {ModuleAndSpecifiers} moduleAndSpecifiers the module request
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
  * @param {ImportDependencyMeta=} dependencyMeta the dependency meta
  * @returns {SourceData} the generated source
@@ -263,7 +270,6 @@ class ModuleExternalInitFragment extends InitFragment {
 			}
 		}
 
-		const identifier = `__WEBPACK_EXTERNAL_MODULE_${ident}__`;
 		super(
 			"",
 			InitFragment.STAGE_HARMONY_IMPORTS,
@@ -273,8 +279,8 @@ class ModuleExternalInitFragment extends InitFragment {
 		this._ident = ident;
 		this._request = request;
 		this._dependencyMeta = dependencyMeta;
-		this._imported = imported;
-		this._identifier = identifier;
+		this._identifier = this.buildIdentifier(ident);
+		this._imported = this.buildImported(imported);
 	}
 
 	/**
@@ -337,6 +343,28 @@ class ModuleExternalInitFragment extends InitFragment {
 	getNamespaceIdentifier() {
 		return this._identifier;
 	}
+
+	/**
+	 * @param {string} ident ident
+	 * @returns {string} identifier
+	 */
+	buildIdentifier(ident) {
+		return `__WEBPACK_EXTERNAL_MODULE_${ident}__`;
+	}
+
+	/**
+	 * @param {Imported} imported imported
+	 * @returns {Imported} normalized imported
+	 */
+	buildImported(imported) {
+		if (Array.isArray(imported)) {
+			return imported.map(([name]) => {
+				const ident = `${this._ident}_${name}`;
+				return [name, this.buildIdentifier(ident)];
+			});
+		}
+		return imported;
+	}
 }
 
 register(
@@ -398,7 +426,7 @@ const generateModuleRemapping = (
 };
 
 /**
- * @param {string|string[]} moduleAndSpecifiers the module request
+ * @param {ModuleAndSpecifiers} moduleAndSpecifiers the module request
  * @param {ExportsInfo} exportsInfo exports info of this module
  * @param {RuntimeSpec} runtime the runtime
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
@@ -433,21 +461,7 @@ const getSourceForModuleExternal = (
 				imported = [];
 				break;
 			default:
-				imported = [];
-				if (exportsInfo.isUsed(runtime) === false) {
-					// no used, only
-				}
-				for (const [name] of usedExports.entries()) {
-					let counter = 0;
-					let finalName = name;
-
-					if (concatenationScope) {
-						while (!concatenationScope.registerUsedName(finalName)) {
-							finalName = `${name}_${counter++}`;
-						}
-					}
-					imported.push([name, finalName]);
-				}
+				imported = [...usedExports.entries()];
 		}
 	}
 
@@ -458,7 +472,24 @@ const getSourceForModuleExternal = (
 		dependencyMeta,
 		runtimeTemplate.outputOptions.hashFunction
 	);
-	const specifiers = imported === true ? undefined : imported;
+	const normalizedImported = initFragment.getImported();
+	const specifiers =
+		normalizedImported === true
+			? undefined
+			: /** @type {[string, string][]} */ (
+					normalizedImported.map(([name, rawFinalName]) => {
+						let finalName = rawFinalName;
+						let counter = 0;
+
+						if (concatenationScope) {
+							while (!concatenationScope.registerUsedName(finalName)) {
+								finalName = `${finalName}_${counter++}`;
+							}
+						}
+						return [name, finalName];
+					})
+				);
+
 	const baseAccess = `${initFragment.getNamespaceIdentifier()}${propertyAccess(
 		moduleAndSpecifiers,
 		1
@@ -498,7 +529,7 @@ const getSourceForModuleExternal = (
 };
 
 /**
- * @param {string|string[]} urlAndGlobal the script request
+ * @param {string | string[]} urlAndGlobal the script request
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
  * @returns {SourceData} the generated source
  */
@@ -546,9 +577,9 @@ const checkExternalVariable = (variableName, request, runtimeTemplate) =>
 	)} }\n`;
 
 /**
- * @param {string|number} id the module id
+ * @param {ModuleId | string} id the module id
  * @param {boolean} optional true, if the module is optional
- * @param {string|string[]} request the request path
+ * @param {string | string[]} request the request path
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
  * @returns {SourceData} the generated source
  */
@@ -575,7 +606,7 @@ const getSourceForAmdOrUmdExternal = (
 
 /**
  * @param {boolean} optional true, if the module is optional
- * @param {string|string[]} request the request path
+ * @param {string | string[]} request the request path
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
  * @returns {SourceData} the generated source
  */
@@ -596,10 +627,11 @@ const getSourceForDefaultCase = (optional, request, runtimeTemplate) => {
 };
 
 /** @typedef {Record<string, string | string[]>} RequestRecord */
+/** @typedef {string | string[] | RequestRecord} ExternalModuleRequest */
 
 class ExternalModule extends Module {
 	/**
-	 * @param {string | string[] | RequestRecord} request request
+	 * @param {ExternalModuleRequest} request request
 	 * @param {string} type type
 	 * @param {string} userRequest user request
 	 * @param {DependencyMeta=} dependencyMeta dependency meta
@@ -608,7 +640,7 @@ class ExternalModule extends Module {
 		super(JAVASCRIPT_MODULE_TYPE_DYNAMIC, null);
 
 		// Info from Factory
-		/** @type {string | string[] | Record<string, string | string[]>} */
+		/** @type {ExternalModuleRequest} */
 		this.request = request;
 		/** @type {string} */
 		this.externalType = type;
@@ -638,7 +670,7 @@ class ExternalModule extends Module {
 
 	/**
 	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
+	 * @returns {LibIdent | null} an identifier for library inclusion
 	 */
 	libIdent(options) {
 		return this.userRequest;
@@ -1020,9 +1052,7 @@ class ExternalModule extends Module {
 						scope.registerRawExport(specifier, finalName);
 					}
 				} else if (concatenationScope) {
-					sourceString = `${
-						runtimeTemplate.supportsConst() ? "const" : "var"
-					} ${ConcatenationScope.NAMESPACE_OBJECT_EXPORT} = ${sourceString};`;
+					sourceString = `${runtimeTemplate.renderConst()} ${ConcatenationScope.NAMESPACE_OBJECT_EXPORT} = ${sourceString};`;
 					concatenationScope.registerNamespaceExport(
 						ConcatenationScope.NAMESPACE_OBJECT_EXPORT
 					);
@@ -1126,3 +1156,5 @@ makeSerializable(ExternalModule, "webpack/lib/ExternalModule");
 
 module.exports = ExternalModule;
 module.exports.ModuleExternalInitFragment = ModuleExternalInitFragment;
+module.exports.getExternalModuleNodeCommonjsInitFragment =
+	getExternalModuleNodeCommonjsInitFragment;

package/lib/ExternalModuleFactoryPlugin.js

@@ -14,16 +14,33 @@ const HarmonyImportDependency = require("./dependencies/HarmonyImportDependency"
 const ImportDependency = require("./dependencies/ImportDependency");
 const { cachedSetProperty, resolveByProperty } = require("./util/cleverMerge");
 
-/** @typedef {import("../declarations/WebpackOptions").ExternalItemFunctionData} ExternalItemFunctionData */
+/** @typedef {import("enhanced-resolve").ResolveContext} ResolveContext */
+/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
+/** @typedef {import("../declarations/WebpackOptions").ExternalItemValue} ExternalItemValue */
 /** @typedef {import("../declarations/WebpackOptions").ExternalItemObjectKnown} ExternalItemObjectKnown */
 /** @typedef {import("../declarations/WebpackOptions").ExternalItemObjectUnknown} ExternalItemObjectUnknown */
 /** @typedef {import("../declarations/WebpackOptions").Externals} Externals */
-/** @typedef {import("./Compilation").DepConstructor} DepConstructor */
 /** @typedef {import("./ExternalModule").DependencyMeta} DependencyMeta */
-/** @typedef {import("./Module")} Module */
 /** @typedef {import("./ModuleFactory").IssuerLayer} IssuerLayer */
+/** @typedef {import("./ModuleFactory").ModuleFactoryCreateDataContextInfo} ModuleFactoryCreateDataContextInfo */
 /** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
 
+/** @typedef {((context: string, request: string, callback: (err?: Error | null, result?: string | false, resolveRequest?: import('enhanced-resolve').ResolveRequest) => void) => void)} ExternalItemFunctionDataGetResolveCallbackResult */
+/** @typedef {((context: string, request: string) => Promise<string>)} ExternalItemFunctionDataGetResolveResult */
+/** @typedef {(options?: ResolveOptions) => ExternalItemFunctionDataGetResolveCallbackResult | ExternalItemFunctionDataGetResolveResult} ExternalItemFunctionDataGetResolve */
+
+/**
+ * @typedef {object} ExternalItemFunctionData
+ * @property {string} context the directory in which the request is placed
+ * @property {ModuleFactoryCreateDataContextInfo} contextInfo contextual information
+ * @property {string} dependencyType the category of the referencing dependency
+ * @property {ExternalItemFunctionDataGetResolve} getResolve get a resolve function with the current resolver options
+ * @property {string} request the request as written by the user in the require/import expression/statement
+ */
+
+/** @typedef {((data: ExternalItemFunctionData, callback: (err?: (Error | null), result?: ExternalItemValue) => void) => void)} ExternalItemFunctionCallback */
+/** @typedef {((data: import("../lib/ExternalModuleFactoryPlugin").ExternalItemFunctionData) => Promise<ExternalItemValue>)} ExternalItemFunctionPromise */
+
 const UNSPECIFIED_EXTERNAL_TYPE_REGEXP = /^[a-z0-9-]+ /;
 const EMPTY_RESOLVE_OPTIONS = {};
 
@@ -79,7 +96,7 @@ const PLUGIN_NAME = "ExternalModuleFactoryPlugin";
 
 class ExternalModuleFactoryPlugin {
 	/**
-	 * @param {string | undefined} type default external type
+	 * @param {string} type default external type
 	 * @param {Externals} externals externals config
 	 */
 	constructor(type, externals) {
@@ -140,7 +157,7 @@ class ExternalModuleFactoryPlugin {
 						}
 					}
 
-					const resolvedType = /** @type {string} */ (type || globalType);
+					const resolvedType = type || globalType;
 
 					// TODO make it pluggable/add hooks to `ExternalModule` to allow output modules own externals?
 					/** @type {DependencyMeta | undefined} */
@@ -159,7 +176,7 @@ class ExternalModuleFactoryPlugin {
 									: undefined;
 
 						dependencyMeta = {
-							attributes: dependency.assertions,
+							attributes: dependency.attributes,
 							externalType
 						};
 					} else if (dependency instanceof CssImportDependency) {
@@ -265,6 +282,7 @@ class ExternalModuleFactoryPlugin {
 									dependencyType,
 									contextInfo,
 									getResolve: (options) => (context, request, callback) => {
+										/** @type {ResolveContext} */
 										const resolveContext = {
 											fileDependencies: data.fileDependencies,
 											missingDependencies: data.missingDependencies,
@@ -307,7 +325,9 @@ class ExternalModuleFactoryPlugin {
 								},
 								cb
 							);
-							if (promise && promise.then) promise.then((r) => cb(null, r), cb);
+							if (promise && promise.then) {
+								promise.then((r) => cb(null, r), cb);
+							}
 						}
 						return;
 					} else if (typeof externals === "object") {