@depup/webpack 5.106.0-depup.0 → 5.109.0-depup.0

package/lib/ExternalModule.js

@@ -8,22 +8,27 @@
 const { SyncBailHook } = require("tapable");
 const { OriginalSource, RawSource } = require("webpack-sources");
 const ConcatenationScope = require("./ConcatenationScope");
-const EnvironmentNotSupportAsyncWarning = require("./EnvironmentNotSupportAsyncWarning");
 const { UsageState } = require("./ExportsInfo");
 const InitFragment = require("./InitFragment");
 const Module = require("./Module");
 const {
+	ASSET_URL_TYPE,
+	ASSET_URL_TYPES,
 	CSS_IMPORT_TYPES,
-	CSS_URL_TYPES,
 	JAVASCRIPT_TYPE,
 	JAVASCRIPT_TYPES
 } = require("./ModuleSourceTypeConstants");
 const { JAVASCRIPT_MODULE_TYPE_DYNAMIC } = require("./ModuleTypeConstants");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const Template = require("./Template");
+const WebpackError = require("./WebpackError");
 const { DEFAULTS } = require("./config/defaults");
+const { ImportPhaseUtils } = require("./dependencies/ImportPhase");
 const StaticExportsDependency = require("./dependencies/StaticExportsDependency");
+const EnvironmentNotSupportAsyncWarning = require("./errors/EnvironmentNotSupportAsyncWarning");
+const { coreModules } = require("./node/nodeBuiltins");
 const createHash = require("./util/createHash");
+const createHooksRegistry = require("./util/createHooksRegistry");
 const extractUrlAndGlobal = require("./util/extractUrlAndGlobal");
 const makeSerializable = require("./util/makeSerializable");
 const { propertyAccess } = require("./util/property");
@@ -62,19 +67,22 @@ const { register } = require("./util/serialization");
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
 /** @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("./dependencies/ImportPhase").ImportPhaseType} ImportPhaseType */
+/** @typedef {import("../declarations/WebpackOptions").ExternalItemInterop} ExternalInterop */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext<[ExternalModuleRequest, ExternalsType, string, DependencyMeta | undefined, ExternalInterop | undefined]>} ObjectDeserializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext<[ExternalModuleRequest, ExternalsType, string, DependencyMeta | undefined, ExternalInterop | undefined]>} ObjectSerializerContext */
 /** @typedef {import("./util/Hash")} Hash */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
-/** @typedef {{ attributes?: ImportAttributes, externalType: "import" | "module" | undefined }} ImportDependencyMeta */
+/** @typedef {{ attributes?: ImportAttributes, phase?: ImportPhaseType, externalType: "import" | "module" | undefined }} ImportDependencyMeta */
 /** @typedef {{ layer?: string, supports?: string, media?: string }} CssImportDependencyMeta */
-/** @typedef {{ sourceType: "css-url" }} AssetDependencyMeta */
+/** @typedef {{ sourceType: "asset-url" | "css-url" }} AssetDependencyMeta */
 
 /** @typedef {ImportDependencyMeta | CssImportDependencyMeta | AssetDependencyMeta} DependencyMeta */
 
 /**
+ * Defines the source data type used by this module.
  * @typedef {object} SourceData
  * @property {boolean=} iife
  * @property {string=} init
@@ -97,7 +105,68 @@ const RUNTIME_REQUIREMENTS_FOR_MODULE = new Set([
 /** @type {RuntimeRequirements} */
 const EMPTY_RUNTIME_REQUIREMENTS = new Set();
 
+const NODE_PREFIX = "node:";
+
+// externals of these types are wired by the library wrapper, which does its own per-key lookup on object externals
+const LIBRARY_WIRED_EXTERNAL_TYPES = new Set([
+	"amd",
+	"amd-require",
+	"umd",
+	"umd2",
+	"system",
+	"jsonp"
+]);
+// External types that emit a node.js-resolvable specifier (`require`/`import`).
+const NODE_RESOLVING_EXTERNAL_TYPES = new Set([
+	"commonjs",
+	"commonjs2",
+	"commonjs-module",
+	"commonjs-static",
+	"node-commonjs",
+	"import",
+	"module"
+]);
+
+/**
+ * Normalizes a node.js core module specifier for the target. Strips `node:`
+ * when the target can't resolve a prefixed request, adds `node:` for a universal
+ * bundle (which may run on deno/bun where the prefix is required), and otherwise
+ * keeps the author's original notation.
+ * @param {string | string[]} request the external request
+ * @param {ExternalsType} externalType the resolved external type
+ * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @returns {string | string[]} the normalized request
+ */
+const normalizeNodeCoreModuleRequest = (
+	request,
+	externalType,
+	runtimeTemplate
+) => {
+	if (!NODE_RESOLVING_EXTERNAL_TYPES.has(externalType)) return request;
+	const name = Array.isArray(request) ? request[0] : request;
+	if (typeof name !== "string") return request;
+	/**
+	 * @param {string} next replacement specifier
+	 * @returns {string | string[]} request with the specifier swapped
+	 */
+	const withName = (next) =>
+		Array.isArray(request) ? [next, ...request.slice(1)] : next;
+
+	if (
+		runtimeTemplate.outputOptions.environment.nodePrefixForCoreModules === false
+	) {
+		if (!name.startsWith(NODE_PREFIX)) return request;
+		const stripped = name.slice(NODE_PREFIX.length);
+		return coreModules.has(stripped) ? withName(stripped) : request;
+	}
+	if (runtimeTemplate.isUniversalTarget() && !name.startsWith(NODE_PREFIX)) {
+		return coreModules.has(name) ? withName(NODE_PREFIX + name) : request;
+	}
+	return request;
+};
+
 /**
+ * Gets source for global variable external.
  * @param {string | string[]} variableName the variable name or path
  * @param {string} type the module system
  * @returns {SourceData} the generated source
@@ -121,6 +190,7 @@ const getSourceForGlobalVariableExternal = (variableName, type) => {
 /** @typedef {string | string[]} ModuleAndSpecifiers */
 
 /**
+ * Gets source for common js external.
  * @param {ModuleAndSpecifiers} moduleAndSpecifiers the module request
  * @returns {SourceData} the generated source
  */
@@ -140,33 +210,55 @@ const getSourceForCommonJsExternal = (moduleAndSpecifiers) => {
 };
 
 /**
+ * Gets external module node commonjs init fragment.
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @param {boolean=} universal target may also run outside node (e.g. `["node", "web"]`)
  * @returns {InitFragment<ChunkRenderContext>} code
  */
-const getExternalModuleNodeCommonjsInitFragment = (runtimeTemplate) => {
+const getExternalModuleNodeCommonjsInitFragment = (
+	runtimeTemplate,
+	universal = false
+) => {
 	const importMetaName = runtimeTemplate.outputOptions.importMetaName;
+	const moduleId = runtimeTemplate.renderNodePrefixForCoreModule("module");
+
+	if (!universal) {
+		return new InitFragment(
+			`import { createRequire as __WEBPACK_EXTERNAL_createRequire } from ${moduleId};\n${runtimeTemplate.renderConst()} __WEBPACK_EXTERNAL_createRequire_require = __WEBPACK_EXTERNAL_createRequire(${importMetaName}.url);\n`,
+			InitFragment.STAGE_HARMONY_IMPORTS,
+			0,
+			"external module node-commonjs"
+		);
+	}
+
+	// defensively obtain `createRequire` so the universal bundle still loads off node
+	const content = `${runtimeTemplate.renderConst()} __WEBPACK_EXTERNAL_createRequire_require = ${runtimeTemplate.getBuiltinModule(
+		moduleId,
+		`.createRequire(${importMetaName}.url)`
+	)};\n`;
 
 	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`,
+		content,
 		InitFragment.STAGE_HARMONY_IMPORTS,
 		0,
-		"external module node-commonjs"
+		"external module node-commonjs universal"
 	);
 };
 
 /**
+ * Gets source for common js external in node module.
  * @param {ModuleAndSpecifiers} moduleAndSpecifiers the module request
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @param {boolean=} universal target may also run outside node (e.g. `["node", "web"]`)
  * @returns {SourceData} the generated source
  */
 const getSourceForCommonJsExternalInNodeModule = (
 	moduleAndSpecifiers,
-	runtimeTemplate
+	runtimeTemplate,
+	universal = false
 ) => {
 	const chunkInitFragments = [
-		getExternalModuleNodeCommonjsInitFragment(runtimeTemplate)
+		getExternalModuleNodeCommonjsInitFragment(runtimeTemplate, universal)
 	];
 	if (!Array.isArray(moduleAndSpecifiers)) {
 		return {
@@ -186,6 +278,7 @@ const getSourceForCommonJsExternalInNodeModule = (
 };
 
 /**
+ * Gets source for import external.
  * @param {ModuleAndSpecifiers} moduleAndSpecifiers the module request
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
  * @param {ImportDependencyMeta=} dependencyMeta the dependency meta
@@ -196,15 +289,25 @@ const getSourceForImportExternal = (
 	runtimeTemplate,
 	dependencyMeta
 ) => {
-	const importName = runtimeTemplate.outputOptions.importFunctionName;
+	const baseImportName = runtimeTemplate.outputOptions.importFunctionName;
 	if (
 		!runtimeTemplate.supportsDynamicImport() &&
-		(importName === "import" || importName === "module-import")
+		(baseImportName === "import" || baseImportName === "module-import")
 	) {
 		throw new Error(
 			"The target environment doesn't support 'import()' so it's not possible to use external type 'import'"
 		);
 	}
+	const phase = dependencyMeta && dependencyMeta.phase;
+	// `import.defer(…)` and `import.source(…)` are only valid forms of the
+	// native `import(…)` function, so we only emit the phase suffix when the
+	// importFunctionName is the default `"import"`.
+	const importName =
+		baseImportName === "import" && ImportPhaseUtils.isDefer(phase)
+			? "import.defer"
+			: baseImportName === "import" && ImportPhaseUtils.isSource(phase)
+				? "import.source"
+				: baseImportName;
 	const attributes =
 		dependencyMeta && dependencyMeta.attributes
 			? dependencyMeta.attributes._isLegacyAssert
@@ -240,6 +343,7 @@ const getSourceForImportExternal = (
 };
 
 /**
+ * Import assertion replacer.
  * @param {string} key key
  * @param {ImportAttributes | string | boolean | undefined} value value
  * @returns {ImportAttributes | string | boolean | undefined} replaced value
@@ -253,10 +357,12 @@ const importAssertionReplacer = (key, value) => {
 };
 
 /**
+ * Represents ModuleExternalInitFragment.
  * @extends {InitFragment<GenerateContext>}
  */
 class ModuleExternalInitFragment extends InitFragment {
 	/**
+	 * Creates an instance of ModuleExternalInitFragment.
 	 * @param {string} request import source
 	 * @param {Imported} imported the imported specifiers
 	 * @param {string=} ident recomputed ident
@@ -284,16 +390,24 @@ class ModuleExternalInitFragment extends InitFragment {
 			"",
 			InitFragment.STAGE_HARMONY_IMPORTS,
 			0,
-			`external module import ${ident} ${imported === true ? imported : imported.join(" ")}`
+			`external module import ${ident} ${
+				imported === true ? imported : imported.join(" ")
+			}`
 		);
+		/** @type {string} */
 		this._ident = ident;
+		/** @type {string} */
 		this._request = request;
+		/** @type {ImportDependencyMeta | undefined} */
 		this._dependencyMeta = dependencyMeta;
+		/** @type {string} */
 		this._identifier = this.buildIdentifier(ident);
+		/** @type {Imported} */
 		this._imported = this.buildImported(imported);
 	}
 
 	/**
+	 * Returns imported.
 	 * @returns {Imported} imported
 	 */
 	getImported() {
@@ -301,6 +415,7 @@ class ModuleExternalInitFragment extends InitFragment {
 	}
 
 	/**
+	 * Updates imported using the provided imported.
 	 * @param {Imported} imported imported
 	 */
 	setImported(imported) {
@@ -308,6 +423,7 @@ class ModuleExternalInitFragment extends InitFragment {
 	}
 
 	/**
+	 * Returns the source code that will be included as initialization code.
 	 * @param {GenerateContext} context context
 	 * @returns {string | Source | undefined} the source code that will be included as initialization code
 	 */
@@ -320,23 +436,34 @@ class ModuleExternalInitFragment extends InitFragment {
 		} = this;
 		const attributes =
 			dependencyMeta && dependencyMeta.attributes
-				? dependencyMeta.attributes._isLegacyAssert &&
-					dependencyMeta.attributes._isLegacyAssert
+				? dependencyMeta.attributes._isLegacyAssert
 					? ` assert ${JSON.stringify(
 							dependencyMeta.attributes,
 							importAssertionReplacer
 						)}`
 					: ` with ${JSON.stringify(dependencyMeta.attributes)}`
 				: "";
+		const phase = dependencyMeta && dependencyMeta.phase;
 		let content = "";
 		if (imported === true) {
 			// namespace
-			content = `import * as ${identifier} from ${JSON.stringify(request)}${
-				attributes
-			};\n`;
+			const phaseKeyword = ImportPhaseUtils.isDefer(phase) ? "defer " : "";
+			content = `import ${phaseKeyword}* 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 if (
+			ImportPhaseUtils.isSource(phase) &&
+			imported.length === 1 &&
+			imported[0][0] === "default"
+		) {
+			// `import source x from "…"` — the source-phase form binds the source
+			// object directly to a single identifier (no namespace, no destructuring).
+			content = `import source ${imported[0][1]} from ${JSON.stringify(
+				request
+			)}${attributes};\n`;
 		} else {
 			content = `import { ${imported
 				.map(([name, finalName]) => {
@@ -355,6 +482,7 @@ class ModuleExternalInitFragment extends InitFragment {
 	}
 
 	/**
+	 * Returns identifier.
 	 * @param {string} ident ident
 	 * @returns {string} identifier
 	 */
@@ -363,6 +491,7 @@ class ModuleExternalInitFragment extends InitFragment {
 	}
 
 	/**
+	 * Returns normalized imported.
 	 * @param {Imported} imported imported
 	 * @returns {Imported} normalized imported
 	 */
@@ -395,6 +524,7 @@ register(
 );
 
 /**
+ * Generates module remapping.
  * @param {string} input input
  * @param {ExportsInfo} exportsInfo the exports info
  * @param {RuntimeSpec=} runtime the runtime
@@ -437,6 +567,7 @@ const generateModuleRemapping = (
 };
 
 /**
+ * Gets source for module external.
  * @param {ModuleAndSpecifiers} moduleAndSpecifiers the module request
  * @param {ExportsInfo} exportsInfo exports info of this module
  * @param {RuntimeSpec} runtime the runtime
@@ -453,6 +584,7 @@ const getSourceForModuleExternal = (
 	dependencyMeta,
 	concatenationScope
 ) => {
+	const phase = dependencyMeta && dependencyMeta.phase;
 	/** @type {Imported} */
 	let imported = true;
 	if (concatenationScope) {
@@ -481,6 +613,14 @@ const getSourceForModuleExternal = (
 		imported = true;
 	}
 
+	// `import defer …` is only valid as `import defer * as ns from "…"`, so
+	// keep the namespace form even if usage analysis would otherwise narrow
+	// the import down to specific names. Defer + concatenation is semantically
+	// at odds (lazy vs. eager), so we preserve the user-written shape here.
+	if (ImportPhaseUtils.isDefer(phase)) {
+		imported = true;
+	}
+
 	const initFragment = new ModuleExternalInitFragment(
 		moduleAndSpecifiers[0],
 		imported,
@@ -511,10 +651,10 @@ const getSourceForModuleExternal = (
 	return {
 		expression,
 		init: moduleRemapping
-			? `var x = ${runtimeTemplate.basicFunction(
+			? `${runtimeTemplate.renderConst()} x = ${runtimeTemplate.basicFunction(
 					"y",
-					`var x = {}; ${RuntimeGlobals.definePropertyGetters}(x, y); return x`
-				)} \nvar y = ${runtimeTemplate.returningFunction(
+					`${runtimeTemplate.renderConst()} x = {}; ${RuntimeGlobals.definePropertyGetters}(x, y); return x`
+				)} \n${runtimeTemplate.renderConst()} y = ${runtimeTemplate.returningFunction(
 					runtimeTemplate.returningFunction("x"),
 					"x"
 				)}`
@@ -530,6 +670,7 @@ const getSourceForModuleExternal = (
 };
 
 /**
+ * Gets source for script external.
  * @param {string | string[]} urlAndGlobal the script request
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
  * @returns {SourceData} the generated source
@@ -541,7 +682,7 @@ const getSourceForScriptExternal = (urlAndGlobal, runtimeTemplate) => {
 	const url = urlAndGlobal[0];
 	const globalName = urlAndGlobal[1];
 	return {
-		init: "var __webpack_error__ = new Error();",
+		init: `${runtimeTemplate.renderConst()} __webpack_error__ = new Error();`,
 		expression: `new Promise(${runtimeTemplate.basicFunction(
 			"resolve, reject",
 			[
@@ -550,12 +691,13 @@ const getSourceForScriptExternal = (urlAndGlobal, runtimeTemplate) => {
 					url
 				)}, ${runtimeTemplate.basicFunction("event", [
 					`if(typeof ${globalName} !== "undefined") return resolve();`,
-					"var errorType = event && (event.type === 'load' ? 'missing' : event.type);",
-					"var realSrc = event && event.target && event.target.src;",
+					`${runtimeTemplate.renderConst()} errorType = event && (event.type === 'load' ? 'missing' : event.type);`,
+					`${runtimeTemplate.renderConst()} realSrc = event && event.target && event.target.src;`,
 					"__webpack_error__.message = 'Loading script failed.\\n(' + errorType + ': ' + realSrc + ')';",
 					"__webpack_error__.name = 'ScriptExternalLoadError';",
 					"__webpack_error__.type = errorType;",
 					"__webpack_error__.request = realSrc;",
+					"__webpack_error__.event = event;",
 					"reject(__webpack_error__);"
 				])}, ${JSON.stringify(globalName)});`
 			]
@@ -567,6 +709,42 @@ const getSourceForScriptExternal = (urlAndGlobal, runtimeTemplate) => {
 };
 
 /**
+ * Gets source for amd-async external. Loads the module at runtime via the
+ * asynchronous AMD `require([...])` API and exposes it as an async module,
+ * so no AMD library wrapper around the chunk is needed.
+ * @param {string | string[]} request the request path
+ * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @returns {SourceData} the generated source
+ */
+const getSourceForAmdAsyncExternal = (request, runtimeTemplate) => {
+	if (!Array.isArray(request)) {
+		request = [request];
+	}
+	const { library } = runtimeTemplate.outputOptions;
+	const amdRequire =
+		library && library.amdContainer
+			? `${library.amdContainer}.require`
+			: "require";
+	return {
+		expression: `new Promise(${runtimeTemplate.basicFunction(
+			"resolve, reject",
+			[
+				`if (typeof ${amdRequire} !== "function") return reject(new Error(${JSON.stringify(
+					`AMD 'require' is not available to load external module ${request[0]}`
+				)}));`,
+				`${amdRequire}(${JSON.stringify([
+					request[0]
+				])}, ${runtimeTemplate.basicFunction(
+					"module",
+					`resolve(module${propertyAccess(request, 1)});`
+				)}, reject);`
+			]
+		)})`
+	};
+};
+
+/**
+ * Checks external variable.
  * @param {string} variableName the variable name to check
  * @param {string} request the request path
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
@@ -578,6 +756,7 @@ const checkExternalVariable = (variableName, request, runtimeTemplate) =>
 	)} }\n`;
 
 /**
+ * Gets source for amd or umd external.
  * @param {ModuleId | string} id the module id
  * @param {boolean} optional true, if the module is optional
  * @param {string | string[]} request the request path
@@ -606,6 +785,7 @@ const getSourceForAmdOrUmdExternal = (
 };
 
 /**
+ * Gets source for default case.
  * @param {boolean} optional true, if the module is optional
  * @param {string | string[]} request the request path
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
@@ -631,23 +811,35 @@ const getSourceForDefaultCase = (optional, request, runtimeTemplate) => {
 /** @typedef {string | string[] | RequestRecord} ExternalModuleRequest */
 
 /**
+ * Defines the external module hooks type used by this module.
  * @typedef {object} ExternalModuleHooks
  * @property {SyncBailHook<[Chunk, Compilation], boolean>} chunkCondition
  */
 
-/** @type {WeakMap<Compilation, ExternalModuleHooks>} */
-const compilationHooksMap = new WeakMap();
+/**
+ * Defines the build info properties specific to external modules.
+ * @typedef {object} KnownExternalModuleBuildInfo
+ * @property {boolean=} javascriptModule true when emitting an ESM external (`output.module`)
+ */
+
+/** @typedef {BuildInfo & KnownExternalModuleBuildInfo} ExternalModuleBuildInfo */
 
 class ExternalModule extends Module {
 	/**
+	 * Creates an instance of ExternalModule.
 	 * @param {ExternalModuleRequest} request request
 	 * @param {ExternalsType} type type
 	 * @param {string} userRequest user request
 	 * @param {DependencyMeta=} dependencyMeta dependency meta
+	 * @param {ExternalInterop=} interop how the external's exports interoperate with ES module imports
 	 */
-	constructor(request, type, userRequest, dependencyMeta) {
+	constructor(request, type, userRequest, dependencyMeta, interop) {
 		super(JAVASCRIPT_MODULE_TYPE_DYNAMIC, null);
 
+		// Redeclared with the external module specific shape
+		/** @type {ExternalModuleBuildInfo | undefined} */
+		this.buildInfo = undefined;
+
 		// Info from Factory
 		/** @type {ExternalModuleRequest} */
 		this.request = request;
@@ -657,34 +849,23 @@ class ExternalModule extends Module {
 		this.userRequest = userRequest;
 		/** @type {DependencyMeta=} */
 		this.dependencyMeta = dependencyMeta;
+		/** @type {ExternalInterop | undefined} interop shape of the external's exports (undefined = importer-driven default) */
+		this.interop = interop;
 	}
 
 	/**
-	 * @param {Compilation} compilation the compilation
-	 * @returns {ExternalModuleHooks} the attached hooks
-	 */
-	static getCompilationHooks(compilation) {
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				chunkCondition: new SyncBailHook(["chunk", "compilation"])
-			};
-			compilationHooksMap.set(compilation, hooks);
-		}
-		return hooks;
-	}
-
-	/**
+	 * Returns the source types this module can generate.
 	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
-		if (
-			this.externalType === "asset" &&
-			this.dependencyMeta &&
-			/** @type {AssetDependencyMeta} */
-			(this.dependencyMeta).sourceType === "css-url"
-		) {
-			return CSS_URL_TYPES;
+		if (this.externalType === "asset" && this.dependencyMeta) {
+			const sourceType =
+				/** @type {AssetDependencyMeta} */
+				(this.dependencyMeta).sourceType;
+			// TODO webpack 6 drop "css-url" once the alias is removed
+			if (sourceType === ASSET_URL_TYPE || sourceType === "css-url") {
+				return ASSET_URL_TYPES;
+			}
 		} else if (this.externalType === "css-import") {
 			return CSS_IMPORT_TYPES;
 		}
@@ -693,6 +874,7 @@ class ExternalModule extends Module {
 	}
 
 	/**
+	 * Gets the library identifier.
 	 * @param {LibIdentOptions} options options
 	 * @returns {LibIdent | null} an identifier for library inclusion
 	 */
@@ -701,6 +883,7 @@ class ExternalModule extends Module {
 	}
 
 	/**
+	 * Returns true if the module can be placed in the chunk.
 	 * @param {Chunk} chunk the chunk which condition should be checked
 	 * @param {Compilation} compilation the compilation
 	 * @returns {boolean} true if the module can be placed in the chunk
@@ -721,13 +904,30 @@ class ExternalModule extends Module {
 	}
 
 	/**
+	 * Returns the unique identifier used to reference this module.
 	 * @returns {string} a unique identifier of the module
 	 */
 	identifier() {
-		return `external ${this._resolveExternalType(this.externalType)} ${JSON.stringify(this.request)}`;
+		let id = `external ${this._resolveExternalType(
+			this.externalType
+		)} ${JSON.stringify(this.request)}`;
+		const meta = /** @type {ImportDependencyMeta | undefined} */ (
+			this.dependencyMeta
+		);
+		if (meta) {
+			if (meta.phase) {
+				id += `|phase=${ImportPhaseUtils.stringify(meta.phase)}`;
+			}
+			if (meta.attributes) {
+				id += `|attributes=${JSON.stringify(meta.attributes)}`;
+			}
+		}
+		if (this.interop) id += `|interop=${this.interop}`;
+		return id;
 	}
 
 	/**
+	 * Returns a human-readable identifier for this module.
 	 * @param {RequestShortener} requestShortener the request shortener
 	 * @returns {string} a user readable identifier of the module
 	 */
@@ -736,6 +936,7 @@ class ExternalModule extends Module {
 	}
 
 	/**
+	 * Checks whether the module needs to be rebuilt for the current build state.
 	 * @param {NeedBuildContext} context context info
 	 * @param {NeedBuildCallback} callback callback function, returns true, if the module needs a rebuild
 	 * @returns {void}
@@ -745,6 +946,7 @@ class ExternalModule extends Module {
 	}
 
 	/**
+	 * Builds the module using the provided compilation context.
 	 * @param {WebpackOptions} options webpack options
 	 * @param {Compilation} compilation the compilation
 	 * @param {ResolverWithOptions} resolver the resolver
@@ -763,6 +965,28 @@ class ExternalModule extends Module {
 			javascriptModule: compilation.outputOptions.module
 		};
 		const { request, externalType } = this._getRequestAndExternalType();
+		if (
+			request === undefined &&
+			typeof this.request === "object" &&
+			!Array.isArray(this.request) &&
+			!LIBRARY_WIRED_EXTERNAL_TYPES.has(this.externalType)
+		) {
+			this.addError(
+				new WebpackError(
+					`Missing external configuration for type "${
+						this.externalType
+					}" in external ${JSON.stringify(
+						this.request
+					)}. Add a ${JSON.stringify(
+						this.externalType
+					)} entry to it or set 'output.externalsType'/'output.library.type' to one of: ${Object.keys(
+						this.request
+					)
+						.map((key) => JSON.stringify(key))
+						.join(", ")}`
+				)
+			);
+		}
 		this.buildMeta.exportsType = "dynamic";
 		let canMangle = false;
 		this.clearDependenciesAndBlocks();
@@ -811,6 +1035,14 @@ class ExternalModule extends Module {
 					"external promise"
 				);
 				break;
+			case "amd-async":
+				this.buildMeta.async = true;
+				EnvironmentNotSupportAsyncWarning.check(
+					this,
+					compilation.runtimeTemplate,
+					"external amd-async"
+				);
+				break;
 			case "import":
 				this.buildMeta.async = true;
 				EnvironmentNotSupportAsyncWarning.check(
@@ -824,6 +1056,20 @@ class ExternalModule extends Module {
 				}
 				break;
 		}
+		// Opt-in override for how the external's exports interoperate with ESM
+		// imports, independent of the importer's strictness (see Rollup's
+		// `output.interop`). Only meaningful for a single-request external.
+		if (this.interop && (!Array.isArray(request) || request.length === 1)) {
+			if (this.interop === "esModule") {
+				// external already is an ES module namespace: `default` unboxes to `.default`
+				this.buildMeta.exportsType = "namespace";
+			} else {
+				// "default": treat as CommonJS, `default` is the whole exports (Node.js semantics)
+				this.buildMeta.exportsType = "default";
+				this.buildMeta.defaultObject = "redirect";
+			}
+			canMangle = false;
+		}
 		this.addDependency(new StaticExportsDependency(true, canMangle));
 		callback();
 	}
@@ -838,6 +1084,7 @@ class ExternalModule extends Module {
 	}
 
 	/**
+	 * Returns the reason this module cannot be concatenated, when one exists.
 	 * @param {ConcatenationBailoutReasonContext} context context
 	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
 	 */
@@ -855,6 +1102,7 @@ class ExternalModule extends Module {
 	}
 
 	/**
+	 * Get request and external type.
 	 * @private
 	 * @returns {{ request: string | string[], externalType: ExternalsType }} the request and external type
 	 */
@@ -901,6 +1149,7 @@ class ExternalModule extends Module {
 	}
 
 	/**
+	 * Returns the source data.
 	 * @private
 	 * @param {string | string[]} request request
 	 * @param {ExternalsType} externalType the external type
@@ -922,6 +1171,11 @@ class ExternalModule extends Module {
 		dependencyMeta,
 		concatenationScope
 	) {
+		request = normalizeNodeCoreModuleRequest(
+			request,
+			externalType,
+			runtimeTemplate
+		);
 		switch (externalType) {
 			case "this":
 			case "window":
@@ -936,11 +1190,24 @@ class ExternalModule extends Module {
 			case "commonjs2":
 			case "commonjs-module":
 			case "commonjs-static":
-				return getSourceForCommonJsExternal(request);
-			case "node-commonjs":
-				return /** @type {BuildInfo} */ (this.buildInfo).javascriptModule
-					? getSourceForCommonJsExternalInNodeModule(request, runtimeTemplate)
-					: getSourceForCommonJsExternal(request);
+			case "node-commonjs": {
+				const { node } = runtimeTemplate.compilation.options.externalsPresets;
+				// ESM has no `require`; load via `createRequire` when the target is node
+				const createRequireInModule =
+					/** @type {BuildInfo} */ (this.buildInfo).javascriptModule &&
+					(externalType === "node-commonjs" || Boolean(node));
+				if (!createRequireInModule) {
+					return getSourceForCommonJsExternal(request);
+				}
+				// for a universal target (e.g. `["node", "web"]`) load defensively so the browser doesn't crash
+				return getSourceForCommonJsExternalInNodeModule(
+					request,
+					runtimeTemplate,
+					runtimeTemplate.isUniversalTarget()
+				);
+			}
+			case "amd-async":
+				return getSourceForAmdAsyncExternal(request, runtimeTemplate);
 			case "amd":
 			case "amd-require":
 			case "umd":
@@ -1007,6 +1274,7 @@ class ExternalModule extends Module {
 	}
 
 	/**
+	 * Generates code and runtime requirements for this module.
 	 * @param {CodeGenerationContext} context context for code generation
 	 * @returns {CodeGenerationResult} result
 	 */
@@ -1031,12 +1299,14 @@ class ExternalModule extends Module {
 				data.set("url", { javascript: /** @type {string} */ (request) });
 				return { sources, runtimeRequirements: RUNTIME_REQUIREMENTS, data };
 			}
-			case "css-url": {
+			// TODO webpack 6 remove "css-url" alias
+			case "css-url":
+			case "asset-url": {
 				/** @type {Sources} */
 				const sources = new Map();
 				/** @type {CodeGenerationResultData} */
 				const data = new Map();
-				data.set("url", { "css-url": /** @type {string} */ (request) });
+				data.set("url", { [ASSET_URL_TYPE]: /** @type {string} */ (request) });
 				return { sources, runtimeRequirements: RUNTIME_REQUIREMENTS, data };
 			}
 			case "css-import": {
@@ -1092,7 +1362,9 @@ class ExternalModule extends Module {
 						scope.registerRawExport(specifier, finalName);
 					}
 				} else if (concatenationScope) {
-					sourceString = `${runtimeTemplate.renderConst()} ${ConcatenationScope.NAMESPACE_OBJECT_EXPORT} = ${sourceString};`;
+					sourceString = `${runtimeTemplate.renderConst()} ${
+						ConcatenationScope.NAMESPACE_OBJECT_EXPORT
+					} = ${sourceString};`;
 					concatenationScope.registerNamespaceExport(
 						ConcatenationScope.NAMESPACE_OBJECT_EXPORT
 					);
@@ -1143,6 +1415,7 @@ class ExternalModule extends Module {
 	}
 
 	/**
+	 * Returns the estimated size for the requested source type.
 	 * @param {string=} type the source type for which the size should be estimated
 	 * @returns {number} the estimated size of the module (must be non-zero)
 	 */
@@ -1151,6 +1424,7 @@ class ExternalModule extends Module {
 	}
 
 	/**
+	 * Updates the hash with the data contributed by this instance.
 	 * @param {Hash} hash the hash used to track dependencies
 	 * @param {UpdateHashContext} context context
 	 * @returns {void}
@@ -1158,42 +1432,66 @@ class ExternalModule extends Module {
 	updateHash(hash, context) {
 		const { chunkGraph } = context;
 		hash.update(
-			`${this._resolveExternalType(this.externalType)}${JSON.stringify(this.request)}${this.isOptional(
-				chunkGraph.moduleGraph
-			)}`
+			`${this._resolveExternalType(this.externalType)}${JSON.stringify(
+				this.request
+			)}${this.isOptional(chunkGraph.moduleGraph)}`
 		);
+		const meta = /** @type {ImportDependencyMeta | undefined} */ (
+			this.dependencyMeta
+		);
+		if (meta) {
+			if (meta.phase) {
+				hash.update(`|phase=${ImportPhaseUtils.stringify(meta.phase)}`);
+			}
+			if (meta.attributes) {
+				hash.update(`|attributes=${JSON.stringify(meta.attributes)}`);
+			}
+		}
+		if (this.interop) hash.update(`|interop=${this.interop}`);
 		super.updateHash(hash, context);
 	}
 
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-
-		write(this.request);
-		write(this.externalType);
-		write(this.userRequest);
-		write(this.dependencyMeta);
+		context
+			.write(this.request)
+			.write(this.externalType)
+			.write(this.userRequest)
+			.write(this.dependencyMeta)
+			.write(this.interop);
 
 		super.serialize(context);
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-
-		this.request = read();
-		this.externalType = read();
-		this.userRequest = read();
-		this.dependencyMeta = read();
-
-		super.deserialize(context);
+		this.request = context.read();
+		const c1 = context.rest;
+		this.externalType = c1.read();
+		const c2 = c1.rest;
+		this.userRequest = c2.read();
+		const c3 = c2.rest;
+		this.dependencyMeta = c3.read();
+		const c4 = c3.rest;
+		this.interop = c4.read();
+
+		super.deserialize(c4.rest);
 	}
 }
 
+ExternalModule.getCompilationHooks = createHooksRegistry(
+	() =>
+		/** @type {ExternalModuleHooks} */ ({
+			chunkCondition: new SyncBailHook(["chunk", "compilation"])
+		})
+);
+
 makeSerializable(ExternalModule, "webpack/lib/ExternalModule");
 
 module.exports = ExternalModule;