webpack 5.97.1 → 5.104.1

package/lib/ExternalModule.js

@@ -12,13 +12,15 @@ const { UsageState } = require("./ExportsInfo");
 const InitFragment = require("./InitFragment");
 const Module = require("./Module");
 const {
-	JS_TYPES,
+	CSS_IMPORT_TYPES,
 	CSS_URL_TYPES,
-	CSS_IMPORT_TYPES
-} = require("./ModuleSourceTypesConstants");
+	JAVASCRIPT_TYPE,
+	JAVASCRIPT_TYPES
+} = require("./ModuleSourceTypeConstants");
 const { JAVASCRIPT_MODULE_TYPE_DYNAMIC } = require("./ModuleTypeConstants");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const Template = require("./Template");
+const { DEFAULTS } = require("./config/defaults");
 const StaticExportsDependency = require("./dependencies/StaticExportsDependency");
 const createHash = require("./util/createHash");
 const extractUrlAndGlobal = require("./util/extractUrlAndGlobal");
@@ -27,20 +29,26 @@ const propertyAccess = require("./util/propertyAccess");
 const { register } = require("./util/serialization");
 
 /** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("../declarations/WebpackOptions").ExternalsType} ExternalsType */
+/** @typedef {import("../declarations/WebpackOptions").HashFunction} HashFunction */
+/** @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 */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
@@ -48,13 +56,11 @@ 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 */
 /** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("./util/Hash")} Hash */
-/** @typedef {typeof import("./util/Hash")} HashConstructor */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
@@ -71,17 +77,20 @@ const { register } = require("./util/serialization");
  * @property {string} expression
  * @property {InitFragment<ChunkRenderContext>[]=} chunkInitFragments
  * @property {ReadOnlyRuntimeRequirements=} runtimeRequirements
+ * @property {[string, string][]=} specifiers
  */
 
+/** @typedef {true | [string, string][]} Imported */
+
 const RUNTIME_REQUIREMENTS = new Set([RuntimeGlobals.module]);
 const RUNTIME_REQUIREMENTS_FOR_SCRIPT = new Set([RuntimeGlobals.loadScript]);
 const RUNTIME_REQUIREMENTS_FOR_MODULE = new Set([
 	RuntimeGlobals.definePropertyGetters
 ]);
-const EMPTY_RUNTIME_REQUIREMENTS = 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
  */
@@ -92,18 +101,22 @@ const getSourceForGlobalVariableExternal = (variableName, type) => {
 	}
 
 	// needed for e.g. window["some"]["thing"]
-	const objectLookup = variableName.map(r => `[${JSON.stringify(r)}]`).join("");
+	const objectLookup = variableName
+		.map((r) => `[${JSON.stringify(r)}]`)
+		.join("");
 	return {
 		iife: type === "this",
 		expression: `${type}${objectLookup}`
 	};
 };
 
+/** @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 => {
+const getSourceForCommonJsExternal = (moduleAndSpecifiers) => {
 	if (!Array.isArray(moduleAndSpecifiers)) {
 		return {
 			expression: `require(${JSON.stringify(moduleAndSpecifiers)})`
@@ -119,30 +132,38 @@ const getSourceForCommonJsExternal = moduleAndSpecifiers => {
 };
 
 /**
- * @param {string|string[]} moduleAndSpecifiers the module request
- * @param {string} importMetaName import.meta name
- * @param {boolean} needPrefix need to use `node:` prefix for `module` import
+ * @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
  */
 const getSourceForCommonJsExternalInNodeModule = (
 	moduleAndSpecifiers,
-	importMetaName,
-	needPrefix
+	runtimeTemplate
 ) => {
 	const chunkInitFragments = [
-		new InitFragment(
-			`import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "${
-				needPrefix ? "node:" : ""
-			}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
 			)})`
 		};
@@ -150,14 +171,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
@@ -212,8 +233,8 @@ const getSourceForImportExternal = (
 
 /**
  * @param {string} key key
- * @param {any | undefined} value value
- * @returns {undefined | string} replaced value
+ * @param {ImportAttributes | string | boolean | undefined} value value
+ * @returns {ImportAttributes | string | boolean | undefined} replaced value
  */
 const importAssertionReplacer = (key, value) => {
 	if (key === "_isLegacyAssert") {
@@ -224,16 +245,23 @@ const importAssertionReplacer = (key, value) => {
 };
 
 /**
- * @extends {InitFragment<ChunkRenderContext>}
+ * @extends {InitFragment<GenerateContext>}
  */
 class ModuleExternalInitFragment extends InitFragment {
 	/**
 	 * @param {string} request import source
+	 * @param {Imported} imported the imported specifiers
 	 * @param {string=} ident recomputed ident
 	 * @param {ImportDependencyMeta=} dependencyMeta the dependency meta
-	 * @param {string | HashConstructor=} hashFunction the hash function to use
+	 * @param {HashFunction=} hashFunction the hash function to use
 	 */
-	constructor(request, ident, dependencyMeta, hashFunction = "md4") {
+	constructor(
+		request,
+		imported,
+		ident,
+		dependencyMeta,
+		hashFunction = DEFAULTS.HASH_FUNCTION
+	) {
 		if (ident === undefined) {
 			ident = Template.toIdentifier(request);
 			if (ident !== request) {
@@ -243,31 +271,102 @@ class ModuleExternalInitFragment extends InitFragment {
 					.slice(0, 8)}`;
 			}
 		}
-		const identifier = `__WEBPACK_EXTERNAL_MODULE_${ident}__`;
+
 		super(
-			`import * as ${identifier} from ${JSON.stringify(request)}${
-				dependencyMeta && dependencyMeta.attributes
-					? dependencyMeta.attributes._isLegacyAssert
-						? ` assert ${JSON.stringify(
-								dependencyMeta.attributes,
-								importAssertionReplacer
-							)}`
-						: ` with ${JSON.stringify(dependencyMeta.attributes)}`
-					: ""
-			};\n`,
+			"",
 			InitFragment.STAGE_HARMONY_IMPORTS,
 			0,
-			`external module import ${ident}`
+			`external module import ${ident} ${imported === true ? imported : imported.join(" ")}`
 		);
 		this._ident = ident;
 		this._request = request;
-		this._dependencyMeta = request;
-		this._identifier = identifier;
+		this._dependencyMeta = dependencyMeta;
+		this._identifier = this.buildIdentifier(ident);
+		this._imported = this.buildImported(imported);
+	}
+
+	/**
+	 * @returns {Imported} imported
+	 */
+	getImported() {
+		return this._imported;
+	}
+
+	/**
+	 * @param {Imported} imported imported
+	 */
+	setImported(imported) {
+		this._imported = imported;
+	}
+
+	/**
+	 * @param {GenerateContext} context context
+	 * @returns {string | Source | undefined} the source code that will be included as initialization code
+	 */
+	getContent(context) {
+		const {
+			_dependencyMeta: dependencyMeta,
+			_imported: imported,
+			_request: request,
+			_identifier: identifier
+		} = this;
+		const attributes =
+			dependencyMeta && dependencyMeta.attributes
+				? dependencyMeta.attributes._isLegacyAssert &&
+					dependencyMeta.attributes._isLegacyAssert
+					? ` assert ${JSON.stringify(
+							dependencyMeta.attributes,
+							importAssertionReplacer
+						)}`
+					: ` with ${JSON.stringify(dependencyMeta.attributes)}`
+				: "";
+		let content = "";
+		if (imported === true) {
+			// namespace
+			content = `import * as ${identifier} from ${JSON.stringify(request)}${
+				attributes
+			};\n`;
+		} else if (imported.length === 0) {
+			// just import, no use
+			content = `import ${JSON.stringify(request)}${attributes};\n`;
+		} else {
+			content = `import { ${imported
+				.map(([name, finalName]) => {
+					if (name !== finalName) {
+						return `${name} as ${finalName}`;
+					}
+					return name;
+				})
+				.join(", ")} } from ${JSON.stringify(request)}${attributes};\n`;
+		}
+		return content;
 	}
 
 	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(
@@ -277,11 +376,12 @@ register(
 	{
 		serialize(obj, { write }) {
 			write(obj._request);
+			write(obj._imported);
 			write(obj._ident);
 			write(obj._dependencyMeta);
 		},
 		deserialize({ read }) {
-			return new ModuleExternalInitFragment(read(), read(), read());
+			return new ModuleExternalInitFragment(read(), read(), read(), read());
 		}
 	}
 );
@@ -328,11 +428,12 @@ 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
  * @param {ImportDependencyMeta} dependencyMeta the dependency meta
+ * @param {ConcatenationScope=} concatenationScope concatenationScope
  * @returns {SourceData} the generated source
  */
 const getSourceForModuleExternal = (
@@ -340,27 +441,63 @@ const getSourceForModuleExternal = (
 	exportsInfo,
 	runtime,
 	runtimeTemplate,
-	dependencyMeta
+	dependencyMeta,
+	concatenationScope
 ) => {
-	if (!Array.isArray(moduleAndSpecifiers))
+	/** @type {Imported} */
+	let imported = true;
+	if (concatenationScope) {
+		const usedExports = exportsInfo.getUsedExports(runtime);
+		switch (usedExports) {
+			case true:
+			case null:
+				// unknown exports
+				imported = true;
+				break;
+			case false:
+				// no used exports
+				imported = [];
+				break;
+			default:
+				imported = [...usedExports.entries()];
+		}
+	}
+
+	if (!Array.isArray(moduleAndSpecifiers)) {
 		moduleAndSpecifiers = [moduleAndSpecifiers];
+	}
+
+	// Return to `namespace` when the external request includes a specific export
+	if (moduleAndSpecifiers.length > 1) {
+		imported = true;
+	}
+
 	const initFragment = new ModuleExternalInitFragment(
 		moduleAndSpecifiers[0],
+		imported,
 		undefined,
 		dependencyMeta,
 		runtimeTemplate.outputOptions.hashFunction
 	);
+	const normalizedImported = initFragment.getImported();
+
 	const baseAccess = `${initFragment.getNamespaceIdentifier()}${propertyAccess(
 		moduleAndSpecifiers,
 		1
 	)}`;
-	const moduleRemapping = generateModuleRemapping(
-		baseAccess,
-		exportsInfo,
-		runtime,
-		runtimeTemplate
-	);
-	const expression = moduleRemapping || baseAccess;
+	let expression = baseAccess;
+
+	const useNamespace = imported === true;
+	let moduleRemapping;
+	if (useNamespace) {
+		moduleRemapping = generateModuleRemapping(
+			baseAccess,
+			exportsInfo,
+			runtime,
+			runtimeTemplate
+		);
+		expression = moduleRemapping || baseAccess;
+	}
 	return {
 		expression,
 		init: moduleRemapping
@@ -372,15 +509,18 @@ const getSourceForModuleExternal = (
 					"x"
 				)}`
 			: undefined,
+		specifiers: normalizedImported === true ? undefined : normalizedImported,
 		runtimeRequirements: moduleRemapping
 			? RUNTIME_REQUIREMENTS_FOR_MODULE
 			: undefined,
-		chunkInitFragments: [initFragment]
+		chunkInitFragments: [
+			/** @type {InitFragment<EXPECTED_ANY>} */ (initFragment)
+		]
 	};
 };
 
 /**
- * @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
  */
@@ -428,9 +568,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
  */
@@ -457,7 +597,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
  */
@@ -478,11 +618,12 @@ 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 {string} type type
+	 * @param {ExternalModuleRequest} request request
+	 * @param {ExternalsType} type type
 	 * @param {string} userRequest user request
 	 * @param {DependencyMeta=} dependencyMeta dependency meta
 	 */
@@ -490,9 +631,9 @@ 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} */
+		/** @type {ExternalsType} */
 		this.externalType = type;
 		/** @type {string} */
 		this.userRequest = userRequest;
@@ -515,12 +656,12 @@ class ExternalModule extends Module {
 			return CSS_IMPORT_TYPES;
 		}
 
-		return JS_TYPES;
+		return JAVASCRIPT_TYPES;
 	}
 
 	/**
 	 * @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;
@@ -554,7 +695,7 @@ class ExternalModule extends Module {
 
 	/**
 	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @param {NeedBuildCallback} callback callback function, returns true, if the module needs a rebuild
 	 * @returns {void}
 	 */
 	needBuild(context, callback) {
@@ -566,7 +707,7 @@ class ExternalModule extends Module {
 	 * @param {Compilation} compilation the compilation
 	 * @param {ResolverWithOptions} resolver the resolver
 	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
+	 * @param {BuildCallback} callback callback function
 	 * @returns {void}
 	 */
 	build(options, compilation, resolver, fs, callback) {
@@ -577,7 +718,7 @@ class ExternalModule extends Module {
 		this.buildInfo = {
 			strict: true,
 			topLevelDeclarations: new Set(),
-			module: compilation.outputOptions.module
+			javascriptModule: compilation.outputOptions.module
 		};
 		const { request, externalType } = this._getRequestAndExternalType();
 		this.buildMeta.exportsType = "dynamic";
@@ -594,7 +735,7 @@ class ExternalModule extends Module {
 				}
 				break;
 			case "module":
-				if (this.buildInfo.module) {
+				if (this.buildInfo.javascriptModule) {
 					if (!Array.isArray(request) || request.length === 1) {
 						this.buildMeta.exportsType = "namespace";
 						canMangle = true;
@@ -647,7 +788,7 @@ class ExternalModule extends Module {
 
 	/**
 	 * restore unsafe cache data
-	 * @param {object} unsafeCacheData data from getUnsafeCacheData
+	 * @param {UnsafeCacheData} unsafeCacheData data from getUnsafeCacheData
 	 * @param {NormalModuleFactory} normalModuleFactory the normal module factory handling the unsafe caching
 	 */
 	restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) {
@@ -658,7 +799,7 @@ class ExternalModule extends Module {
 	 * @param {ConcatenationBailoutReasonContext} context context
 	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
 	 */
-	getConcatenationBailoutReason({ moduleGraph }) {
+	getConcatenationBailoutReason(context) {
 		switch (this.externalType) {
 			case "amd":
 			case "amd-require":
@@ -671,10 +812,15 @@ class ExternalModule extends Module {
 		return undefined;
 	}
 
+	/**
+	 * @private
+	 * @returns {{ request: string | string[], externalType: ExternalsType }} the request and external type
+	 */
 	_getRequestAndExternalType() {
 		let { request, externalType } = this;
-		if (typeof request === "object" && !Array.isArray(request))
+		if (typeof request === "object" && !Array.isArray(request)) {
 			request = request[externalType];
+		}
 		externalType = this._resolveExternalType(externalType);
 		return { request, externalType };
 	}
@@ -682,8 +828,8 @@ class ExternalModule extends Module {
 	/**
 	 * Resolve the detailed external type from the raw external type.
 	 * e.g. resolve "module" or "import" from "module-import" type
-	 * @param {string} externalType raw external type
-	 * @returns {string} resolved external type
+	 * @param {ExternalsType} externalType raw external type
+	 * @returns {ExternalsType} resolved external type
 	 */
 	_resolveExternalType(externalType) {
 		if (externalType === "module-import") {
@@ -715,12 +861,13 @@ class ExternalModule extends Module {
 	/**
 	 * @private
 	 * @param {string | string[]} request request
-	 * @param {string} externalType the external type
+	 * @param {ExternalsType} externalType the external type
 	 * @param {RuntimeTemplate} runtimeTemplate the runtime template
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @param {ChunkGraph} chunkGraph the chunk graph
 	 * @param {RuntimeSpec} runtime the runtime
 	 * @param {DependencyMeta | undefined} dependencyMeta the dependency meta
+	 * @param {ConcatenationScope=} concatenationScope concatenationScope
 	 * @returns {SourceData} the source data
 	 */
 	_getSourceData(
@@ -730,7 +877,8 @@ class ExternalModule extends Module {
 		moduleGraph,
 		chunkGraph,
 		runtime,
-		dependencyMeta
+		dependencyMeta,
+		concatenationScope
 	) {
 		switch (externalType) {
 			case "this":
@@ -748,14 +896,8 @@ class ExternalModule extends Module {
 			case "commonjs-static":
 				return getSourceForCommonJsExternal(request);
 			case "node-commonjs":
-				return /** @type {BuildInfo} */ (this.buildInfo).module
-					? getSourceForCommonJsExternalInNodeModule(
-							request,
-							/** @type {string} */
-							(runtimeTemplate.outputOptions.importMetaName),
-							/** @type {boolean} */
-							(runtimeTemplate.supportNodePrefixForCoreModules())
-						)
+				return /** @type {BuildInfo} */ (this.buildInfo).javascriptModule
+					? getSourceForCommonJsExternalInNodeModule(request, runtimeTemplate)
 					: getSourceForCommonJsExternal(request);
 			case "amd":
 			case "amd-require":
@@ -780,7 +922,7 @@ class ExternalModule extends Module {
 			case "script":
 				return getSourceForScriptExternal(request, runtimeTemplate);
 			case "module": {
-				if (!(/** @type {BuildInfo} */ (this.buildInfo).module)) {
+				if (!(/** @type {BuildInfo} */ (this.buildInfo).javascriptModule)) {
 					if (!runtimeTemplate.supportsDynamicImport()) {
 						throw new Error(
 							`The target environment doesn't support dynamic import() syntax so it's not possible to use external type 'module' within a script${
@@ -806,13 +948,12 @@ class ExternalModule extends Module {
 					moduleGraph.getExportsInfo(this),
 					runtime,
 					runtimeTemplate,
-					/** @type {ImportDependencyMeta} */ (dependencyMeta)
+					/** @type {ImportDependencyMeta} */ (dependencyMeta),
+					concatenationScope
 				);
 			}
 			case "var":
 			case "promise":
-			case "const":
-			case "let":
 			case "assign":
 			default:
 				return getSourceForDefaultCase(
@@ -839,7 +980,7 @@ class ExternalModule extends Module {
 			case "asset": {
 				const sources = new Map();
 				sources.set(
-					"javascript",
+					JAVASCRIPT_TYPE,
 					new RawSource(`module.exports = ${JSON.stringify(request)};`)
 				);
 				const data = new Map();
@@ -886,24 +1027,34 @@ class ExternalModule extends Module {
 					moduleGraph,
 					chunkGraph,
 					runtime,
-					this.dependencyMeta
+					this.dependencyMeta,
+					concatenationScope
 				);
 
+				// sourceString can be empty str only when there is concatenationScope
 				let sourceString = sourceData.expression;
-				if (sourceData.iife)
+				if (sourceData.iife) {
 					sourceString = `(function() { return ${sourceString}; }())`;
-				if (concatenationScope) {
-					sourceString = `${
-						runtimeTemplate.supportsConst() ? "const" : "var"
-					} ${ConcatenationScope.NAMESPACE_OBJECT_EXPORT} = ${sourceString};`;
+				}
+
+				const specifiers = sourceData.specifiers;
+				if (specifiers) {
+					sourceString = "";
+					const scope = /** @type {ConcatenationScope} */ (concatenationScope);
+					for (const [specifier, finalName] of specifiers) {
+						scope.registerRawExport(specifier, finalName);
+					}
+				} else if (concatenationScope) {
+					sourceString = `${runtimeTemplate.renderConst()} ${ConcatenationScope.NAMESPACE_OBJECT_EXPORT} = ${sourceString};`;
 					concatenationScope.registerNamespaceExport(
 						ConcatenationScope.NAMESPACE_OBJECT_EXPORT
 					);
 				} else {
 					sourceString = `module.exports = ${sourceString};`;
 				}
-				if (sourceData.init)
+				if (sourceData.init) {
 					sourceString = `${sourceData.init}\n${sourceString}`;
+				}
 
 				let data;
 				if (sourceData.chunkInitFragments) {
@@ -914,11 +1065,11 @@ class ExternalModule extends Module {
 				const sources = new Map();
 				if (this.useSourceMap || this.useSimpleSourceMap) {
 					sources.set(
-						"javascript",
+						JAVASCRIPT_TYPE,
 						new OriginalSource(sourceString, this.identifier())
 					);
 				} else {
-					sources.set("javascript", new RawSource(sourceString));
+					sources.set(JAVASCRIPT_TYPE, new RawSource(sourceString));
 				}
 
 				let runtimeRequirements = sourceData.runtimeRequirements;
@@ -997,3 +1148,6 @@ class ExternalModule extends Module {
 makeSerializable(ExternalModule, "webpack/lib/ExternalModule");
 
 module.exports = ExternalModule;
+module.exports.ModuleExternalInitFragment = ModuleExternalInitFragment;
+module.exports.getExternalModuleNodeCommonjsInitFragment =
+	getExternalModuleNodeCommonjsInitFragment;