webpack 5.90.3 → 5.92.0

package/lib/DllReferencePlugin.js

@@ -17,6 +17,7 @@ const makePathsRelative = require("./util/identifier").makePathsRelative;
 /** @typedef {import("../declarations/plugins/DllReferencePlugin").DllReferencePluginOptions} DllReferencePluginOptions */
 /** @typedef {import("../declarations/plugins/DllReferencePlugin").DllReferencePluginOptionsManifest} DllReferencePluginOptionsManifest */
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 
 const validate = createSchemaValidation(
 	require("../schemas/plugins/DllReferencePlugin.check.js"),
@@ -34,7 +35,7 @@ class DllReferencePlugin {
 	constructor(options) {
 		validate(options);
 		this.options = options;
-		/** @type {WeakMap<Object, {path: string, data: DllReferencePluginOptionsManifest?, error: Error?}>} */
+		/** @type {WeakMap<object, {path: string, data: DllReferencePluginOptionsManifest?, error: Error?}>} */
 		this._compilationData = new WeakMap();
 	}
 
@@ -60,7 +61,8 @@ class DllReferencePlugin {
 				if ("manifest" in this.options) {
 					const manifest = this.options.manifest;
 					if (typeof manifest === "string") {
-						compiler.inputFileSystem.readFile(manifest, (err, result) => {
+						/** @type {InputFileSystem} */
+						(compiler.inputFileSystem).readFile(manifest, (err, result) => {
 							if (err) return callback(err);
 							const data = {
 								path: manifest,
@@ -70,7 +72,9 @@ class DllReferencePlugin {
 							// Catch errors parsing the manifest so that blank
 							// or malformed manifest files don't kill the process.
 							try {
-								data.data = parseJson(result.toString("utf-8"));
+								data.data = parseJson(
+									/** @type {Buffer} */ (result).toString("utf-8")
+								);
 							} catch (e) {
 								// Store the error in the params so that it can
 								// be added as a compilation error later on.

package/lib/EntryOptionPlugin.js

@@ -41,7 +41,10 @@ class EntryOptionPlugin {
 					name,
 					desc
 				);
-				for (const entry of desc.import) {
+				const descImport =
+					/** @type {Exclude<EntryDescription["import"], undefined>} */
+					(desc.import);
+				for (const entry of descImport) {
 					new EntryPlugin(context, entry, options).apply(compiler);
 				}
 			}

package/lib/EntryPlugin.js

@@ -59,7 +59,12 @@ class EntryPlugin {
 	static createDependency(entry, options) {
 		const dep = new EntryDependency(entry);
 		// TODO webpack 6 remove string option
-		dep.loc = { name: typeof options === "object" ? options.name : options };
+		dep.loc = {
+			name:
+				typeof options === "object"
+					? /** @type {string} */ (options.name)
+					: options
+		};
 		return dep;
 	}
 }

package/lib/Entrypoint.js

@@ -89,7 +89,7 @@ class Entrypoint extends ChunkGroup {
 	/**
 	 * @param {Chunk} oldChunk chunk to be replaced
 	 * @param {Chunk} newChunk New chunk that will be replaced with
-	 * @returns {boolean} returns true if the replacement was successful
+	 * @returns {boolean | undefined} returns true if the replacement was successful
 	 */
 	replaceChunk(oldChunk, newChunk) {
 		if (this._runtimeChunk === oldChunk) this._runtimeChunk = newChunk;

package/lib/EvalDevToolModulePlugin.js

@@ -12,6 +12,7 @@ const RuntimeGlobals = require("./RuntimeGlobals");
 const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin");
 
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../declarations/WebpackOptions").OutputNormalized} OutputOptions */
 /** @typedef {import("./Compiler")} Compiler */
 
 /** @type {WeakMap<Source, Source>} */
@@ -27,7 +28,17 @@ const devtoolWarning = new RawSource(`/*
  */
 `);
 
+/**
+ * @typedef {object} EvalDevToolModulePluginOptions
+ * @property {OutputOptions["devtoolNamespace"]=} namespace namespace
+ * @property {string=} sourceUrlComment source url comment
+ * @property {OutputOptions["devtoolModuleFilenameTemplate"]=} moduleFilenameTemplate module filename template
+ */
+
 class EvalDevToolModulePlugin {
+	/**
+	 * @param {EvalDevToolModulePluginOptions=} options options
+	 */
 	constructor(options) {
 		this.namespace = options.namespace || "";
 		this.sourceUrlComment = options.sourceUrlComment || "\n//# sourceURL=[url]";

package/lib/ExportsInfo.js

@@ -171,6 +171,10 @@ class ExportsInfo {
 		this._exportsAreOrdered = true;
 	}
 
+	/**
+	 * @param {ExportsInfo | undefined} exportsInfo exports info
+	 * @returns {boolean} result
+	 */
 	setRedirectNamedTo(exportsInfo) {
 		if (this._redirectTo === exportsInfo) return false;
 		this._redirectTo = exportsInfo;
@@ -207,9 +211,6 @@ class ExportsInfo {
 			this._redirectTo.setHasUseInfo();
 		} else {
 			this._otherExportsInfo.setHasUseInfo();
-			if (this._otherExportsInfo.canMangleUse === undefined) {
-				this._otherExportsInfo.canMangleUse = true;
-			}
 		}
 	}
 
@@ -479,6 +480,7 @@ class ExportsInfo {
 	 * @returns {SortableSet<string> | boolean | null} set of used exports, or true (when namespace object is used), or false (when unused), or null (when unknown)
 	 */
 	getUsedExports(runtime) {
+		// eslint-disable-next-line no-constant-binary-expression
 		if (!this._redirectTo !== undefined) {
 			switch (this._otherExportsInfo.getUsed(runtime)) {
 				case UsageState.NoInfo:
@@ -527,6 +529,7 @@ class ExportsInfo {
 	 * @returns {null | true | string[]} list of exports when known
 	 */
 	getProvidedExports() {
+		// eslint-disable-next-line no-constant-binary-expression
 		if (!this._redirectTo !== undefined) {
 			switch (this._otherExportsInfo.provided) {
 				case undefined:
@@ -670,7 +673,7 @@ class ExportsInfo {
 	}
 
 	/**
-	 * @param {string | string[]} name the export name
+	 * @param {string | string[] | undefined} name the export name
 	 * @param {RuntimeSpec} runtime check usage for this runtime only
 	 * @returns {string | string[] | false} the used name
 	 */
@@ -807,16 +810,28 @@ class ExportInfo {
 	constructor(name, initFrom) {
 		/** @type {string} */
 		this.name = name;
-		/** @private @type {string | null} */
+		/**
+		 * @private
+		 * @type {string | null}
+		 */
 		this._usedName = initFrom ? initFrom._usedName : null;
-		/** @private @type {UsageStateType} */
+		/**
+		 * @private
+		 * @type {UsageStateType}
+		 */
 		this._globalUsed = initFrom ? initFrom._globalUsed : undefined;
-		/** @private @type {Map<string, RuntimeUsageStateType>} */
+		/**
+		 * @private
+		 * @type {Map<string, RuntimeUsageStateType>}
+		 */
 		this._usedInRuntime =
 			initFrom && initFrom._usedInRuntime
 				? new Map(initFrom._usedInRuntime)
 				: undefined;
-		/** @private @type {boolean} */
+		/**
+		 * @private
+		 * @type {boolean}
+		 */
 		this._hasUseInRuntimeInfo = initFrom
 			? initFrom._hasUseInRuntimeInfo
 			: false;

package/lib/ExternalModule.js

@@ -29,18 +29,23 @@ const { register } = require("./util/serialization");
 /** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("./DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("./ExportsInfo")} ExportsInfo */
+/** @typedef {import("./Generator").GenerateContext} GenerateContext */
+/** @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").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("./Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
 /** @typedef {import("./Module").SourceTypes} SourceTypes */
+/** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
 /** @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 */
@@ -48,13 +53,18 @@ const { register } = require("./util/serialization");
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
+/** @typedef {{ attributes?: ImportAttributes }} ImportDependencyMeta */
+/** @typedef {{ layer?: string, supports?: string, media?: string }} CssImportDependencyMeta */
+
+/** @typedef {ImportDependencyMeta | CssImportDependencyMeta} DependencyMeta */
+
 /**
- * @typedef {Object} SourceData
+ * @typedef {object} SourceData
  * @property {boolean=} iife
  * @property {string=} init
  * @property {string} expression
  * @property {InitFragment<ChunkRenderContext>[]=} chunkInitFragments
- * @property {ReadonlySet<string>=} runtimeRequirements
+ * @property {ReadOnlyRuntimeRequirements=} runtimeRequirements
  */
 
 const TYPES = new Set(["javascript"]);
@@ -107,15 +117,19 @@ 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
  * @returns {SourceData} the generated source
  */
 const getSourceForCommonJsExternalInNodeModule = (
 	moduleAndSpecifiers,
-	importMetaName
+	importMetaName,
+	needPrefix
 ) => {
 	const chunkInitFragments = [
 		new InitFragment(
-			'import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "module";\n',
+			`import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "${
+				needPrefix ? "node:" : ""
+			}module";\n`,
 			InitFragment.STAGE_HARMONY_IMPORTS,
 			0,
 			"external module node-commonjs"
@@ -141,43 +155,78 @@ const getSourceForCommonJsExternalInNodeModule = (
 /**
  * @param {string|string[]} moduleAndSpecifiers the module request
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @param {ImportDependencyMeta=} dependencyMeta the dependency meta
  * @returns {SourceData} the generated source
  */
-const getSourceForImportExternal = (moduleAndSpecifiers, runtimeTemplate) => {
+const getSourceForImportExternal = (
+	moduleAndSpecifiers,
+	runtimeTemplate,
+	dependencyMeta
+) => {
 	const importName = runtimeTemplate.outputOptions.importFunctionName;
 	if (!runtimeTemplate.supportsDynamicImport() && importName === "import") {
 		throw new Error(
 			"The target environment doesn't support 'import()' so it's not possible to use external type 'import'"
 		);
 	}
+	const attributes =
+		dependencyMeta && dependencyMeta.attributes
+			? dependencyMeta.attributes._isLegacyAssert
+				? `, { assert: ${JSON.stringify(
+						dependencyMeta.attributes,
+						importAssertionReplacer
+					)} }`
+				: `, { with: ${JSON.stringify(dependencyMeta.attributes)} }`
+			: "";
 	if (!Array.isArray(moduleAndSpecifiers)) {
 		return {
-			expression: `${importName}(${JSON.stringify(moduleAndSpecifiers)});`
+			expression: `${importName}(${JSON.stringify(
+				moduleAndSpecifiers
+			)}${attributes});`
 		};
 	}
 	if (moduleAndSpecifiers.length === 1) {
 		return {
-			expression: `${importName}(${JSON.stringify(moduleAndSpecifiers[0])});`
+			expression: `${importName}(${JSON.stringify(
+				moduleAndSpecifiers[0]
+			)}${attributes});`
 		};
 	}
 	const moduleName = moduleAndSpecifiers[0];
 	return {
 		expression: `${importName}(${JSON.stringify(
 			moduleName
-		)}).then(${runtimeTemplate.returningFunction(
+		)}${attributes}).then(${runtimeTemplate.returningFunction(
 			`module${propertyAccess(moduleAndSpecifiers, 1)}`,
 			"module"
 		)});`
 	};
 };
 
+/**
+ * @param {string} key key
+ * @param {any | undefined} value value
+ * @returns {undefined | string} replaced value
+ */
+const importAssertionReplacer = (key, value) => {
+	if (key === "_isLegacyAssert") {
+		return undefined;
+	}
+
+	return value;
+};
+
+/**
+ * @extends {InitFragment<ChunkRenderContext>}
+ */
 class ModuleExternalInitFragment extends InitFragment {
 	/**
 	 * @param {string} request import source
 	 * @param {string=} ident recomputed ident
+	 * @param {ImportDependencyMeta=} dependencyMeta the dependency meta
 	 * @param {string | HashConstructor=} hashFunction the hash function to use
 	 */
-	constructor(request, ident, hashFunction = "md4") {
+	constructor(request, ident, dependencyMeta, hashFunction = "md4") {
 		if (ident === undefined) {
 			ident = Template.toIdentifier(request);
 			if (ident !== request) {
@@ -189,14 +238,24 @@ class ModuleExternalInitFragment extends InitFragment {
 		}
 		const identifier = `__WEBPACK_EXTERNAL_MODULE_${ident}__`;
 		super(
-			`import * as ${identifier} from ${JSON.stringify(request)};\n`,
+			`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}`
 		);
 		this._ident = ident;
-		this._identifier = identifier;
 		this._request = request;
+		this._dependencyMeta = request;
+		this._identifier = identifier;
 	}
 
 	getNamespaceIdentifier() {
@@ -212,13 +271,21 @@ register(
 		serialize(obj, { write }) {
 			write(obj._request);
 			write(obj._ident);
+			write(obj._dependencyMeta);
 		},
 		deserialize({ read }) {
-			return new ModuleExternalInitFragment(read(), read());
+			return new ModuleExternalInitFragment(read(), read(), read());
 		}
 	}
 );
 
+/**
+ * @param {string} input input
+ * @param {ExportsInfo} exportsInfo the exports info
+ * @param {RuntimeSpec=} runtime the runtime
+ * @param {RuntimeTemplate=} runtimeTemplate the runtime template
+ * @returns {string | undefined} the module remapping
+ */
 const generateModuleRemapping = (
 	input,
 	exportsInfo,
@@ -242,9 +309,11 @@ const generateModuleRemapping = (
 				}
 			}
 			properties.push(
-				`[${JSON.stringify(used)}]: ${runtimeTemplate.returningFunction(
-					`${input}${propertyAccess([exportInfo.name])}`
-				)}`
+				`[${JSON.stringify(used)}]: ${
+					/** @type {RuntimeTemplate} */ (runtimeTemplate).returningFunction(
+						`${input}${propertyAccess([exportInfo.name])}`
+					)
+				}`
 			);
 		}
 		return `x({ ${properties.join(", ")} })`;
@@ -256,19 +325,22 @@ const generateModuleRemapping = (
  * @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
  * @returns {SourceData} the generated source
  */
 const getSourceForModuleExternal = (
 	moduleAndSpecifiers,
 	exportsInfo,
 	runtime,
-	runtimeTemplate
+	runtimeTemplate,
+	dependencyMeta
 ) => {
 	if (!Array.isArray(moduleAndSpecifiers))
 		moduleAndSpecifiers = [moduleAndSpecifiers];
 	const initFragment = new ModuleExternalInitFragment(
 		moduleAndSpecifiers[0],
 		undefined,
+		dependencyMeta,
 		runtimeTemplate.outputOptions.hashFunction
 	);
 	const baseAccess = `${initFragment.getNamespaceIdentifier()}${propertyAccess(
@@ -284,13 +356,15 @@ const getSourceForModuleExternal = (
 	let expression = moduleRemapping || baseAccess;
 	return {
 		expression,
-		init: `var x = ${runtimeTemplate.basicFunction(
-			"y",
-			`var x = {}; ${RuntimeGlobals.definePropertyGetters}(x, y); return x`
-		)} \nvar y = ${runtimeTemplate.returningFunction(
-			runtimeTemplate.returningFunction("x"),
-			"x"
-		)}`,
+		init: moduleRemapping
+			? `var x = ${runtimeTemplate.basicFunction(
+					"y",
+					`var x = {}; ${RuntimeGlobals.definePropertyGetters}(x, y); return x`
+				)} \nvar y = ${runtimeTemplate.returningFunction(
+					runtimeTemplate.returningFunction("x"),
+					"x"
+				)}`
+			: undefined,
 		runtimeRequirements: moduleRemapping
 			? RUNTIME_REQUIREMENTS_FOR_MODULE
 			: undefined,
@@ -397,13 +471,16 @@ const getSourceForDefaultCase = (optional, request, runtimeTemplate) => {
 	};
 };
 
+/** @typedef {Record<string, string | string[]>} RequestRecord */
+
 class ExternalModule extends Module {
 	/**
-	 * @param {string | string[] | Record<string, string | string[]>} request request
-	 * @param {TODO} type type
+	 * @param {string | string[] | RequestRecord} request request
+	 * @param {string} type type
 	 * @param {string} userRequest user request
+	 * @param {DependencyMeta=} dependencyMeta dependency meta
 	 */
-	constructor(request, type, userRequest) {
+	constructor(request, type, userRequest, dependencyMeta) {
 		super(JAVASCRIPT_MODULE_TYPE_DYNAMIC, null);
 
 		// Info from Factory
@@ -413,6 +490,8 @@ class ExternalModule extends Module {
 		this.externalType = type;
 		/** @type {string} */
 		this.userRequest = userRequest;
+		/** @type {DependencyMeta=} */
+		this.dependencyMeta = dependencyMeta;
 	}
 
 	/**
@@ -549,6 +628,11 @@ class ExternalModule extends Module {
 		callback();
 	}
 
+	/**
+	 * restore unsafe cache data
+	 * @param {object} unsafeCacheData data from getUnsafeCacheData
+	 * @param {NormalModuleFactory} normalModuleFactory the normal module factory handling the unsafe caching
+	 */
 	restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) {
 		this._restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory);
 	}
@@ -577,13 +661,25 @@ class ExternalModule extends Module {
 		return { request, externalType };
 	}
 
+	/**
+	 * @private
+	 * @param {string | string[]} request request
+	 * @param {string} 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
+	 * @returns {SourceData} the source data
+	 */
 	_getSourceData(
 		request,
 		externalType,
 		runtimeTemplate,
 		moduleGraph,
 		chunkGraph,
-		runtime
+		runtime,
+		dependencyMeta
 	) {
 		switch (externalType) {
 			case "this":
@@ -601,10 +697,12 @@ class ExternalModule extends Module {
 			case "commonjs-static":
 				return getSourceForCommonJsExternal(request);
 			case "node-commonjs":
-				return this.buildInfo.module
+				return /** @type {BuildInfo} */ (this.buildInfo).module
 					? getSourceForCommonJsExternalInNodeModule(
 							request,
-							runtimeTemplate.outputOptions.importMetaName
+							/** @type {string} */
+							(runtimeTemplate.outputOptions.importMetaName),
+							runtimeTemplate.supportNodePrefixForCoreModules()
 						)
 					: getSourceForCommonJsExternal(request);
 			case "amd":
@@ -622,11 +720,15 @@ class ExternalModule extends Module {
 				);
 			}
 			case "import":
-				return getSourceForImportExternal(request, runtimeTemplate);
+				return getSourceForImportExternal(
+					request,
+					runtimeTemplate,
+					/** @type {ImportDependencyMeta} */ (dependencyMeta)
+				);
 			case "script":
 				return getSourceForScriptExternal(request, runtimeTemplate);
 			case "module": {
-				if (!this.buildInfo.module) {
+				if (!(/** @type {BuildInfo} */ (this.buildInfo).module)) {
 					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" +
@@ -635,7 +737,11 @@ class ExternalModule extends Module {
 									: "")
 						);
 					}
-					return getSourceForImportExternal(request, runtimeTemplate);
+					return getSourceForImportExternal(
+						request,
+						runtimeTemplate,
+						/** @type {ImportDependencyMeta} */ (dependencyMeta)
+					);
 				}
 				if (!runtimeTemplate.supportsEcmaScriptModuleSyntax()) {
 					throw new Error(
@@ -646,7 +752,8 @@ class ExternalModule extends Module {
 					request,
 					moduleGraph.getExportsInfo(this),
 					runtime,
-					runtimeTemplate
+					runtimeTemplate,
+					/** @type {ImportDependencyMeta} */ (dependencyMeta)
 				);
 			}
 			case "var":
@@ -688,9 +795,24 @@ class ExternalModule extends Module {
 			}
 			case "css-import": {
 				const sources = new Map();
+				const dependencyMeta = /** @type {CssImportDependencyMeta} */ (
+					this.dependencyMeta
+				);
+				const layer =
+					dependencyMeta.layer !== undefined
+						? ` layer(${dependencyMeta.layer})`
+						: "";
+				const supports = dependencyMeta.supports
+					? ` supports(${dependencyMeta.supports})`
+					: "";
+				const media = dependencyMeta.media ? ` ${dependencyMeta.media}` : "";
 				sources.set(
 					"css-import",
-					new RawSource(`@import url(${JSON.stringify(request)});`)
+					new RawSource(
+						`@import url(${JSON.stringify(
+							request
+						)})${layer}${supports}${media};`
+					)
 				);
 				return {
 					sources,
@@ -704,7 +826,8 @@ class ExternalModule extends Module {
 					runtimeTemplate,
 					moduleGraph,
 					chunkGraph,
-					runtime
+					runtime,
+					this.dependencyMeta
 				);
 
 				let sourceString = sourceData.expression;
@@ -792,6 +915,7 @@ class ExternalModule extends Module {
 		write(this.request);
 		write(this.externalType);
 		write(this.userRequest);
+		write(this.dependencyMeta);
 
 		super.serialize(context);
 	}
@@ -805,6 +929,7 @@ class ExternalModule extends Module {
 		this.request = read();
 		this.externalType = read();
 		this.userRequest = read();
+		this.dependencyMeta = read();
 
 		super.deserialize(context);
 	}

package/lib/ExternalModuleFactoryPlugin.js

@@ -7,9 +7,16 @@
 
 const util = require("util");
 const ExternalModule = require("./ExternalModule");
+const ContextElementDependency = require("./dependencies/ContextElementDependency");
+const CssImportDependency = require("./dependencies/CssImportDependency");
+const HarmonyImportDependency = require("./dependencies/HarmonyImportDependency");
+const ImportDependency = require("./dependencies/ImportDependency");
 const { resolveByProperty, cachedSetProperty } = require("./util/cleverMerge");
 
 /** @typedef {import("../declarations/WebpackOptions").Externals} Externals */
+/** @typedef {import("./Compilation").DepConstructor} DepConstructor */
+/** @typedef {import("./ExternalModule").DependencyMeta} DependencyMeta */
+/** @typedef {import("./Module")} Module */
 /** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
 
 const UNSPECIFIED_EXTERNAL_TYPE_REGEXP = /^[a-z0-9-]+ /;
@@ -67,7 +74,7 @@ class ExternalModuleFactoryPlugin {
 				/**
 				 * @param {string|string[]|boolean|Record<string, string|string[]>} value the external config
 				 * @param {string|undefined} type type of external
-				 * @param {function(Error=, ExternalModule=): void} callback callback
+				 * @param {function((Error | null)=, ExternalModule=): void} callback callback
 				 * @returns {void}
 				 */
 				const handleExternal = (value, type, callback) => {
@@ -105,12 +112,34 @@ class ExternalModuleFactoryPlugin {
 							];
 						}
 					}
+
+					// TODO make it pluggable/add hooks to `ExternalModule` to allow output modules own externals?
+					/** @type {DependencyMeta | undefined} */
+					let dependencyMeta;
+
+					if (
+						dependency instanceof HarmonyImportDependency ||
+						dependency instanceof ImportDependency ||
+						dependency instanceof ContextElementDependency
+					) {
+						dependencyMeta = {
+							attributes: dependency.assertions
+						};
+					} else if (dependency instanceof CssImportDependency) {
+						dependencyMeta = {
+							layer: dependency.layer,
+							supports: dependency.supports,
+							media: dependency.media
+						};
+					}
+
 					callback(
 						null,
 						new ExternalModule(
 							externalConfig,
 							type || globalType,
-							dependency.request
+							dependency.request,
+							dependencyMeta
 						)
 					);
 				};
@@ -128,7 +157,13 @@ class ExternalModuleFactoryPlugin {
 					} else if (Array.isArray(externals)) {
 						let i = 0;
 						const next = () => {
+							/** @type {boolean | undefined} */
 							let asyncFlag;
+							/**
+							 * @param {(Error | null)=} err err
+							 * @param {ExternalModule=} module module
+							 * @returns {void}
+							 */
 							const handleExternalsAndCallback = (err, module) => {
 								if (err) return callback(err);
 								if (!module) {