webpack 5.97.1 → 5.104.1

package/lib/NormalModuleFactory.js

@@ -9,10 +9,10 @@ const { getContext } = require("loader-runner");
 const asyncLib = require("neo-async");
 const {
 	AsyncSeriesBailHook,
-	SyncWaterfallHook,
+	HookMap,
 	SyncBailHook,
 	SyncHook,
-	HookMap
+	SyncWaterfallHook
 } = require("tapable");
 const ChunkGraph = require("./ChunkGraph");
 const Module = require("./Module");
@@ -34,9 +34,13 @@ const {
 	parseResourceWithoutFragment
 } = require("./util/identifier");
 
+/** @typedef {import("enhanced-resolve").ResolveContext} ResolveContext */
+/** @typedef {import("enhanced-resolve").ResolveRequest} ResolveRequest */
 /** @typedef {import("../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
 /** @typedef {import("../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
+/** @typedef {import("./Compilation").FileSystemDependencies} FileSystemDependencies */
 /** @typedef {import("./Generator")} Generator */
+/** @typedef {import("./ModuleFactory").ModuleFactoryCallback} ModuleFactoryCallback */
 /** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
 /** @typedef {import("./ModuleFactory").ModuleFactoryCreateDataContextInfo} ModuleFactoryCreateDataContextInfo */
 /** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
@@ -46,13 +50,19 @@ const {
 /** @typedef {import("./NormalModule").ParserOptions} ParserOptions */
 /** @typedef {import("./Parser")} Parser */
 /** @typedef {import("./ResolverFactory")} ResolverFactory */
-/** @typedef {import("./ResolverFactory").ResolveContext} ResolveContext */
-/** @typedef {import("./ResolverFactory").ResolveRequest} ResolveRequest */
 /** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("./dependencies/ModuleDependency")} ModuleDependency */
+/** @typedef {import("./javascript/JavascriptParser").ImportAttributes} ImportAttributes */
+/** @typedef {import("./rules/RuleSetCompiler").RuleSetRules} RuleSetRules */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("./util/identifier").AssociatedObjectForCache} AssociatedObjectForCache */
 
-/** @typedef {Pick<RuleSetRule, 'type' | 'sideEffects' | 'parser' | 'generator' | 'resolve' | 'layer'>} ModuleSettings */
+/**
+ * @template T
+ * @typedef {import("./Compiler").Callback<T>} Callback
+ */
+
+/** @typedef {Pick<RuleSetRule, "type" | "sideEffects" | "parser" | "generator" | "resolve" | "layer" | "extractSourceMap">} ModuleSettings */
 /** @typedef {Partial<NormalModuleCreateData & { settings: ModuleSettings }>} CreateData */
 
 /**
@@ -61,13 +71,13 @@ const {
  * @property {ModuleFactoryCreateData["resolveOptions"]} resolveOptions
  * @property {string} context
  * @property {string} request
- * @property {Record<string, any> | undefined} assertions
+ * @property {ImportAttributes | undefined} attributes
  * @property {ModuleDependency[]} dependencies
  * @property {string} dependencyType
  * @property {CreateData} createData
- * @property {LazySet<string>} fileDependencies
- * @property {LazySet<string>} missingDependencies
- * @property {LazySet<string>} contextDependencies
+ * @property {FileSystemDependencies} fileDependencies
+ * @property {FileSystemDependencies} missingDependencies
+ * @property {FileSystemDependencies} contextDependencies
  * @property {Module=} ignoredModule
  * @property {boolean} cacheable allow to use the unsafe cache
  */
@@ -81,7 +91,15 @@ const {
  * @property {string=} context
  */
 
-/** @typedef {ResourceData & { data: Record<string, any> }} ResourceDataWithData */
+/**
+ * @typedef {object} ResourceSchemeData
+ * @property {string=} mimetype mime type of the resource
+ * @property {string=} parameters additional parameters for the resource
+ * @property {"base64" | false=} encoding encoding of the resource
+ * @property {string=} encodedContent encoded content of the resource
+ */
+
+/** @typedef {ResourceData & { data: ResourceSchemeData & Partial<ResolveRequest> }} ResourceDataWithData */
 
 /**
  * @typedef {object} ParsedLoaderRequest
@@ -89,13 +107,24 @@ const {
  * @property {string|undefined} options options
  */
 
-/**
- * @template T
- * @callback Callback
- * @param {(Error | null)=} err
- * @param {T=} stats
- * @returns {void}
- */
+/** @typedef {import("./ModuleTypeConstants").JAVASCRIPT_MODULE_TYPE_AUTO} JAVASCRIPT_MODULE_TYPE_AUTO */
+/** @typedef {import("./ModuleTypeConstants").JAVASCRIPT_MODULE_TYPE_DYNAMIC} JAVASCRIPT_MODULE_TYPE_DYNAMIC */
+/** @typedef {import("./ModuleTypeConstants").JAVASCRIPT_MODULE_TYPE_ESM} JAVASCRIPT_MODULE_TYPE_ESM */
+/** @typedef {import("./ModuleTypeConstants").JSON_MODULE_TYPE} JSON_MODULE_TYPE */
+/** @typedef {import("./ModuleTypeConstants").ASSET_MODULE_TYPE} ASSET_MODULE_TYPE */
+/** @typedef {import("./ModuleTypeConstants").ASSET_MODULE_TYPE_INLINE} ASSET_MODULE_TYPE_INLINE */
+/** @typedef {import("./ModuleTypeConstants").ASSET_MODULE_TYPE_RESOURCE} ASSET_MODULE_TYPE_RESOURCE */
+/** @typedef {import("./ModuleTypeConstants").ASSET_MODULE_TYPE_SOURCE} ASSET_MODULE_TYPE_SOURCE */
+/** @typedef {import("./ModuleTypeConstants").ASSET_MODULE_TYPE_BYTES} ASSET_MODULE_TYPE_BYTES */
+/** @typedef {import("./ModuleTypeConstants").WEBASSEMBLY_MODULE_TYPE_ASYNC} WEBASSEMBLY_MODULE_TYPE_ASYNC */
+/** @typedef {import("./ModuleTypeConstants").WEBASSEMBLY_MODULE_TYPE_SYNC} WEBASSEMBLY_MODULE_TYPE_SYNC */
+/** @typedef {import("./ModuleTypeConstants").CSS_MODULE_TYPE} CSS_MODULE_TYPE */
+/** @typedef {import("./ModuleTypeConstants").CSS_MODULE_TYPE_GLOBAL} CSS_MODULE_TYPE_GLOBAL */
+/** @typedef {import("./ModuleTypeConstants").CSS_MODULE_TYPE_MODULE} CSS_MODULE_TYPE_MODULE */
+/** @typedef {import("./ModuleTypeConstants").CSS_MODULE_TYPE_AUTO} CSS_MODULE_TYPE_AUTO */
+
+/** @typedef {JAVASCRIPT_MODULE_TYPE_AUTO | JAVASCRIPT_MODULE_TYPE_DYNAMIC | JAVASCRIPT_MODULE_TYPE_ESM | JSON_MODULE_TYPE | ASSET_MODULE_TYPE | ASSET_MODULE_TYPE_INLINE | ASSET_MODULE_TYPE_RESOURCE | ASSET_MODULE_TYPE_SOURCE | WEBASSEMBLY_MODULE_TYPE_ASYNC | WEBASSEMBLY_MODULE_TYPE_SYNC | CSS_MODULE_TYPE | CSS_MODULE_TYPE_GLOBAL | CSS_MODULE_TYPE_MODULE | CSS_MODULE_TYPE_AUTO} KnownNormalModuleTypes */
+/** @typedef {KnownNormalModuleTypes | string} NormalModuleTypes */
 
 const EMPTY_RESOLVE_OPTIONS = {};
 /** @type {ParserOptions} */
@@ -112,7 +141,7 @@ const LEADING_DOT_EXTENSION_REGEX = /^[^.]/;
  * @param {LoaderItem} data data
  * @returns {string} ident
  */
-const loaderToIdent = data => {
+const loaderToIdent = (data) => {
 	if (!data.options) {
 		return data.loader;
 	}
@@ -146,7 +175,7 @@ const stringifyLoadersAndResource = (loaders, resource) => {
  * @param {(err?: null | Error) => void} callback callback
  * @returns {(err?: null | Error) => void} callback
  */
-const needCalls = (times, callback) => err => {
+const needCalls = (times, callback) => (err) => {
 	if (--times === 0) {
 		return callback(err);
 	}
@@ -186,20 +215,13 @@ const mergeGlobalOptions = (globalOptions, type, localOptions) => {
 
 // TODO webpack 6 remove
 /**
+ * @template {import("tapable").Hook<EXPECTED_ANY, EXPECTED_ANY>} T
  * @param {string} name name
- * @param {TODO} hook hook
+ * @param {T} hook hook
  * @returns {string} result
  */
 const deprecationChangedHookMessage = (name, hook) => {
-	const names = hook.taps
-		.map(
-			/**
-			 * @param {TODO} tapped tapped
-			 * @returns {string} name
-			 */
-			tapped => tapped.name
-		)
-		.join(", ");
+	const names = hook.taps.map((tapped) => tapped.name).join(", ");
 
 	return (
 		`NormalModuleFactory.${name} (${names}) is no longer a waterfall hook, but a bailing hook instead. ` +
@@ -222,16 +244,18 @@ const ruleSetCompiler = new RuleSetCompiler([
 	new BasicMatcherRulePlugin("issuer"),
 	new BasicMatcherRulePlugin("compiler"),
 	new BasicMatcherRulePlugin("issuerLayer"),
-	new ObjectMatcherRulePlugin("assert", "assertions", value => {
+	new ObjectMatcherRulePlugin("assert", "attributes", (value) => {
 		if (value) {
-			return /** @type {any} */ (value)._isLegacyAssert !== undefined;
+			return (
+				/** @type {ImportAttributes} */ (value)._isLegacyAssert !== undefined
+			);
 		}
 
 		return false;
 	}),
-	new ObjectMatcherRulePlugin("with", "assertions", value => {
+	new ObjectMatcherRulePlugin("with", "attributes", (value) => {
 		if (value) {
-			return !(/** @type {any} */ (value)._isLegacyAssert);
+			return !(/** @type {ImportAttributes} */ (value)._isLegacyAssert);
 		}
 		return false;
 	}),
@@ -242,9 +266,76 @@ const ruleSetCompiler = new RuleSetCompiler([
 	new BasicEffectRulePlugin("resolve"),
 	new BasicEffectRulePlugin("generator"),
 	new BasicEffectRulePlugin("layer"),
+	new BasicEffectRulePlugin("extractSourceMap"),
 	new UseEffectRulePlugin()
 ]);
 
+/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("./javascript/JavascriptGenerator")} JavascriptGenerator */
+/** @typedef {import("../declarations/WebpackOptions").EmptyGeneratorOptions} EmptyGeneratorOptions */
+
+/** @typedef {import("./json/JsonParser")} JsonParser */
+/** @typedef {import("../declarations/WebpackOptions").JsonParserOptions} JsonParserOptions */
+/** @typedef {import("./json/JsonGenerator")} JsonGenerator */
+/** @typedef {import("../declarations/WebpackOptions").JsonGeneratorOptions} JsonGeneratorOptions */
+
+/** @typedef {import("./asset/AssetParser")} AssetParser */
+/** @typedef {import("./asset/AssetSourceParser")} AssetSourceParser */
+/** @typedef {import("./asset/AssetBytesParser")} AssetBytesParser */
+/** @typedef {import("../declarations/WebpackOptions").AssetParserOptions} AssetParserOptions */
+/** @typedef {import("../declarations/WebpackOptions").EmptyParserOptions} EmptyParserOptions */
+/** @typedef {import("./asset/AssetGenerator")} AssetGenerator */
+/** @typedef {import("../declarations/WebpackOptions").AssetGeneratorOptions} AssetGeneratorOptions */
+/** @typedef {import("../declarations/WebpackOptions").AssetInlineGeneratorOptions} AssetInlineGeneratorOptions */
+/** @typedef {import("../declarations/WebpackOptions").AssetResourceGeneratorOptions} AssetResourceGeneratorOptions */
+/** @typedef {import("./asset/AssetSourceGenerator")} AssetSourceGenerator */
+/** @typedef {import("./asset/AssetBytesGenerator")} AssetBytesGenerator */
+
+/** @typedef {import("./wasm-async/AsyncWebAssemblyParser")} AsyncWebAssemblyParser */
+/** @typedef {import("./wasm-sync/WebAssemblyParser")} WebAssemblyParser */
+
+/** @typedef {import("./css/CssParser")} CssParser */
+/** @typedef {import("../declarations/WebpackOptions").CssParserOptions} CssParserOptions */
+/** @typedef {import("../declarations/WebpackOptions").CssModuleParserOptions} CssModuleParserOptions */
+/** @typedef {import("./css/CssGenerator")} CssGenerator */
+/** @typedef {import("../declarations/WebpackOptions").CssGeneratorOptions} CssGeneratorOptions */
+/** @typedef {import("../declarations/WebpackOptions").CssModuleGeneratorOptions} CssModuleGeneratorOptions */
+
+/**
+ * @typedef {[
+ * [JAVASCRIPT_MODULE_TYPE_AUTO, JavascriptParser, JavascriptParserOptions, JavascriptGenerator, EmptyGeneratorOptions],
+ * [JAVASCRIPT_MODULE_TYPE_DYNAMIC, JavascriptParser, JavascriptParserOptions, JavascriptGenerator, EmptyGeneratorOptions],
+ * [JAVASCRIPT_MODULE_TYPE_ESM, JavascriptParser, JavascriptParserOptions, JavascriptGenerator, EmptyGeneratorOptions],
+ * [JSON_MODULE_TYPE, JsonParser, JsonParserOptions, JsonGenerator, JsonGeneratorOptions],
+ * [ASSET_MODULE_TYPE, AssetParser, AssetParserOptions, AssetGenerator, AssetGeneratorOptions],
+ * [ASSET_MODULE_TYPE_INLINE, AssetParser, EmptyParserOptions, AssetGenerator, AssetGeneratorOptions],
+ * [ASSET_MODULE_TYPE_RESOURCE, AssetParser, EmptyParserOptions, AssetGenerator, AssetGeneratorOptions],
+ * [ASSET_MODULE_TYPE_SOURCE, AssetSourceParser, EmptyParserOptions, AssetSourceGenerator, EmptyGeneratorOptions],
+ * [ASSET_MODULE_TYPE_BYTES, AssetBytesParser, EmptyParserOptions, AssetBytesGenerator, EmptyGeneratorOptions],
+ * [WEBASSEMBLY_MODULE_TYPE_ASYNC, AsyncWebAssemblyParser, EmptyParserOptions, Generator, EmptyParserOptions],
+ * [WEBASSEMBLY_MODULE_TYPE_SYNC, WebAssemblyParser, EmptyParserOptions, Generator, EmptyParserOptions],
+ * [CSS_MODULE_TYPE, CssParser, CssParserOptions, CssGenerator, CssGeneratorOptions],
+ * [CSS_MODULE_TYPE_AUTO, CssParser, CssModuleParserOptions, CssGenerator, CssModuleGeneratorOptions],
+ * [CSS_MODULE_TYPE_MODULE, CssParser, CssModuleParserOptions, CssGenerator, CssModuleGeneratorOptions],
+ * [CSS_MODULE_TYPE_GLOBAL, CssParser, CssModuleParserOptions, CssGenerator, CssModuleGeneratorOptions],
+ * [string, Parser, ParserOptions, Generator, GeneratorOptions],
+ * ]} ParsersAndGeneratorsByTypes
+ */
+
+/**
+ * @template {unknown[]} T
+ * @template {number[]} I
+ * @typedef {{ [K in keyof I]: K extends keyof I ? I[K] extends keyof T ? T[I[K]] : never : never }} ExtractTupleElements
+ */
+
+/**
+ * @template {unknown[]} T
+ * @template {number[]} A
+ * @template [R=void]
+ * @typedef {T extends [infer Head extends [string, ...unknown[]], ...infer Tail extends [string, ...unknown[]][]] ? Record<Head[0], SyncBailHook<ExtractTupleElements<Head, A>, R extends number ? Head[R] : R>> & RecordFactoryFromTuple<Tail, A, R> : unknown } RecordFactoryFromTuple
+ */
+
 class NormalModuleFactory extends ModuleFactory {
 	/**
 	 * @param {object} param params
@@ -252,16 +343,14 @@ class NormalModuleFactory extends ModuleFactory {
 	 * @param {InputFileSystem} param.fs file system
 	 * @param {ResolverFactory} param.resolverFactory resolverFactory
 	 * @param {ModuleOptions} param.options options
-	 * @param {object} param.associatedObjectForCache an object to which the cache will be attached
-	 * @param {boolean=} param.layers enable layers
+	 * @param {AssociatedObjectForCache} param.associatedObjectForCache an object to which the cache will be attached
 	 */
 	constructor({
 		context,
 		fs,
 		resolverFactory,
 		options,
-		associatedObjectForCache,
-		layers = false
+		associatedObjectForCache
 	}) {
 		super();
 		this.hooks = Object.freeze({
@@ -281,23 +370,23 @@ class NormalModuleFactory extends ModuleFactory {
 			beforeResolve: new AsyncSeriesBailHook(["resolveData"]),
 			/** @type {AsyncSeriesBailHook<[ResolveData], false | void>} */
 			afterResolve: new AsyncSeriesBailHook(["resolveData"]),
-			/** @type {AsyncSeriesBailHook<[ResolveData["createData"], ResolveData], Module | void>} */
+			/** @type {AsyncSeriesBailHook<[CreateData, ResolveData], Module | void>} */
 			createModule: new AsyncSeriesBailHook(["createData", "resolveData"]),
-			/** @type {SyncWaterfallHook<[Module, ResolveData["createData"], ResolveData]>} */
+			/** @type {SyncWaterfallHook<[Module, CreateData, ResolveData]>} */
 			module: new SyncWaterfallHook(["module", "createData", "resolveData"]),
-			/** @type {HookMap<SyncBailHook<[ParserOptions], Parser | void>>} */
+			/** @type {import("tapable").TypedHookMap<RecordFactoryFromTuple<ParsersAndGeneratorsByTypes, [2], 1>>} */
 			createParser: new HookMap(() => new SyncBailHook(["parserOptions"])),
-			/** @type {HookMap<SyncBailHook<[TODO, ParserOptions], void>>} */
+			/** @type {import("tapable").TypedHookMap<RecordFactoryFromTuple<ParsersAndGeneratorsByTypes, [1, 2]>>} */
 			parser: new HookMap(() => new SyncHook(["parser", "parserOptions"])),
-			/** @type {HookMap<SyncBailHook<[GeneratorOptions], Generator | void>>} */
+			/** @type {import("tapable").TypedHookMap<RecordFactoryFromTuple<ParsersAndGeneratorsByTypes, [4], 3>>} */
 			createGenerator: new HookMap(
 				() => new SyncBailHook(["generatorOptions"])
 			),
-			/** @type {HookMap<SyncBailHook<[TODO, GeneratorOptions], void>>} */
+			/** @type {import("tapable").TypedHookMap<RecordFactoryFromTuple<ParsersAndGeneratorsByTypes, [3, 4]>>} */
 			generator: new HookMap(
 				() => new SyncHook(["generator", "generatorOptions"])
 			),
-			/** @type {HookMap<SyncBailHook<[TODO, ResolveData], Module | void>>} */
+			/** @type {HookMap<SyncBailHook<[CreateData, ResolveData], Module | void>>} */
 			createModuleClass: new HookMap(
 				() => new SyncBailHook(["createData", "resolveData"])
 			)
@@ -305,23 +394,24 @@ class NormalModuleFactory extends ModuleFactory {
 		this.resolverFactory = resolverFactory;
 		this.ruleSet = ruleSetCompiler.compile([
 			{
-				rules: options.defaultRules
+				rules: /** @type {RuleSetRules} */ (options.defaultRules)
 			},
 			{
-				rules: options.rules
+				rules: /** @type {RuleSetRules} */ (options.rules)
 			}
 		]);
 		this.context = context || "";
 		this.fs = fs;
 		this._globalParserOptions = options.parser;
 		this._globalGeneratorOptions = options.generator;
-		/** @type {Map<string, WeakMap<object, Parser>>} */
+		/** @type {Map<string, WeakMap<ParserOptions, Parser>>} */
 		this.parserCache = new Map();
-		/** @type {Map<string, WeakMap<object, Generator>>} */
+		/** @type {Map<string, WeakMap<GeneratorOptions, Generator>>} */
 		this.generatorCache = new Map();
 		/** @type {Set<Module>} */
 		this._restoredUnsafeCacheEntries = new Set();
 
+		/** @type {(resource: string) => import("./util/identifier").ParsedResource} */
 		const cacheParseResource = parseResource.bindCache(
 			associatedObjectForCache
 		);
@@ -344,24 +434,26 @@ class NormalModuleFactory extends ModuleFactory {
 					// direct module
 					if (result instanceof Module) return callback(null, result);
 
-					if (typeof result === "object")
+					if (typeof result === "object") {
 						throw new Error(
 							`${deprecationChangedHookMessage(
 								"resolve",
 								this.hooks.resolve
 							)} Returning a Module object will result in this module used as result.`
 						);
+					}
 
 					this.hooks.afterResolve.callAsync(resolveData, (err, result) => {
 						if (err) return callback(err);
 
-						if (typeof result === "object")
+						if (typeof result === "object") {
 							throw new Error(
 								deprecationChangedHookMessage(
 									"afterResolve",
 									this.hooks.afterResolve
 								)
 							);
+						}
 
 						// Ignored
 						if (result === false) return callback();
@@ -420,7 +512,7 @@ class NormalModuleFactory extends ModuleFactory {
 					dependencies,
 					dependencyType,
 					request,
-					assertions,
+					attributes,
 					resolveOptions,
 					fileDependencies,
 					missingDependencies,
@@ -448,20 +540,22 @@ class NormalModuleFactory extends ModuleFactory {
 					const matchResourceMatch = MATCH_RESOURCE_REGEX.exec(request);
 					if (matchResourceMatch) {
 						let matchResource = matchResourceMatch[1];
+						// Check if matchResource starts with ./ or ../
 						if (matchResource.charCodeAt(0) === 46) {
-							// 46 === ".", 47 === "/"
+							// 46 is "."
 							const secondChar = matchResource.charCodeAt(1);
 							if (
-								secondChar === 47 ||
-								(secondChar === 46 && matchResource.charCodeAt(2) === 47)
+								secondChar === 47 || // 47 is "/"
+								(secondChar === 46 && matchResource.charCodeAt(2) === 47) // "../"
 							) {
-								// if matchResources startsWith ../ or ./
+								// Resolve relative path against context
 								matchResource = join(this.fs, context, matchResource);
 							}
 						}
+
 						matchResourceData = {
-							resource: matchResource,
-							...cacheParseResource(matchResource)
+							...cacheParseResource(matchResource),
+							resource: matchResource
 						};
 						requestWithoutMatchResource = request.slice(
 							matchResourceMatch[0].length
@@ -486,7 +580,7 @@ class NormalModuleFactory extends ModuleFactory {
 							)
 							.split(/!+/);
 						unresolvedResource = /** @type {string} */ (rawElements.pop());
-						elements = rawElements.map(el => {
+						elements = rawElements.map((el) => {
 							const { path, query } = cachedParseResourceWithoutFragment(el);
 							return {
 								loader: path,
@@ -516,7 +610,7 @@ class NormalModuleFactory extends ModuleFactory {
 				/** @type {undefined | LoaderItem[]} */
 				let loaders;
 
-				const continueCallback = needCalls(2, err => {
+				const continueCallback = needCalls(2, (err) => {
 					if (err) return callback(err);
 
 					// translate option idents
@@ -560,8 +654,11 @@ class NormalModuleFactory extends ModuleFactory {
 
 					/** @type {ModuleSettings} */
 					const settings = {};
+					/** @type {LoaderItem[]} */
 					const useLoadersPost = [];
+					/** @type {LoaderItem[]} */
 					const useLoaders = [];
+					/** @type {LoaderItem[]} */
 					const useLoadersPre = [];
 
 					// handle .webpack[] suffix
@@ -586,7 +683,7 @@ class NormalModuleFactory extends ModuleFactory {
 							resourceQuery: resourceDataForRules.query,
 							resourceFragment: resourceDataForRules.fragment,
 							scheme,
-							assertions,
+							attributes,
 							mimetype: matchResourceData
 								? ""
 								: resourceData.data.mimetype || "",
@@ -620,16 +717,16 @@ class NormalModuleFactory extends ModuleFactory {
 								typeof r.value === "object" &&
 								r.value !== null &&
 								typeof settings[
-									/** @type {keyof ModuleSettings} */ (r.type)
+									/** @type {keyof ModuleSettings} */
+									(r.type)
 								] === "object" &&
 								settings[/** @type {keyof ModuleSettings} */ (r.type)] !== null
 							) {
-								settings[r.type] = cachedCleverMerge(
-									settings[/** @type {keyof ModuleSettings} */ (r.type)],
-									r.value
-								);
+								const type = /** @type {keyof ModuleSettings} */ (r.type);
+								settings[type] = cachedCleverMerge(settings[type], r.value);
 							} else {
-								settings[r.type] = r.value;
+								const type = /** @type {keyof ModuleSettings} */ (r.type);
+								settings[type] = r.value;
 							}
 						}
 					}
@@ -641,34 +738,37 @@ class NormalModuleFactory extends ModuleFactory {
 					/** @type {undefined | LoaderItem[]} */
 					let preLoaders;
 
-					const continueCallback = needCalls(3, err => {
+					const continueCallback = needCalls(3, (err) => {
 						if (err) {
 							return callback(err);
 						}
 						const allLoaders = /** @type {LoaderItem[]} */ (postLoaders);
 						if (matchResourceData === undefined) {
-							for (const loader of /** @type {LoaderItem[]} */ (loaders))
+							for (const loader of /** @type {LoaderItem[]} */ (loaders)) {
 								allLoaders.push(loader);
-							for (const loader of /** @type {LoaderItem[]} */ (normalLoaders))
+							}
+							for (const loader of /** @type {LoaderItem[]} */ (
+								normalLoaders
+							)) {
 								allLoaders.push(loader);
+							}
 						} else {
-							for (const loader of /** @type {LoaderItem[]} */ (normalLoaders))
+							for (const loader of /** @type {LoaderItem[]} */ (
+								normalLoaders
+							)) {
 								allLoaders.push(loader);
-							for (const loader of /** @type {LoaderItem[]} */ (loaders))
+							}
+							for (const loader of /** @type {LoaderItem[]} */ (loaders)) {
 								allLoaders.push(loader);
+							}
 						}
-						for (const loader of /** @type {LoaderItem[]} */ (preLoaders))
+						for (const loader of /** @type {LoaderItem[]} */ (preLoaders)) {
 							allLoaders.push(loader);
-						const type = /** @type {string} */ (settings.type);
+						}
+						const type = /** @type {NormalModuleTypes} */ (settings.type);
 						const resolveOptions = settings.resolve;
 						const layer = settings.layer;
-						if (layer !== undefined && !layers) {
-							return callback(
-								new Error(
-									"'Rule.layer' is only allowed when 'experiments.layers' is enabled"
-								)
-							);
-						}
+
 						try {
 							Object.assign(data.createData, {
 								layer:
@@ -693,7 +793,8 @@ class NormalModuleFactory extends ModuleFactory {
 								parserOptions: settings.parser,
 								generator: this.getGenerator(type, settings.generator),
 								generatorOptions: settings.generator,
-								resolveOptions
+								resolveOptions,
+								extractSourceMap: settings.extractSourceMap || false
 							});
 						} catch (createDataErr) {
 							return callback(/** @type {Error} */ (createDataErr));
@@ -751,12 +852,12 @@ class NormalModuleFactory extends ModuleFactory {
 				/**
 				 * @param {string} context context
 				 */
-				const defaultResolve = context => {
+				const defaultResolve = (context) => {
 					if (/^($|\?)/.test(unresolvedResource)) {
 						resourceData = {
+							...cacheParseResource(unresolvedResource),
 							resource: unresolvedResource,
-							data: {},
-							...cacheParseResource(unresolvedResource)
+							data: {}
 						};
 						continueCallback();
 					}
@@ -786,11 +887,11 @@ class NormalModuleFactory extends ModuleFactory {
 										/** @type {string} */
 										(_resolvedResource);
 									resourceData = {
+										...cacheParseResource(resolvedResource),
 										resource: resolvedResource,
 										data:
 											/** @type {ResolveRequest} */
-											(resolvedResourceResolveData),
-										...cacheParseResource(resolvedResource)
+											(resolvedResourceResolveData)
 									};
 								}
 								continueCallback();
@@ -811,7 +912,7 @@ class NormalModuleFactory extends ModuleFactory {
 					};
 					this.hooks.resolveForScheme
 						.for(scheme)
-						.callAsync(resourceData, data, err => {
+						.callAsync(resourceData, data, (err) => {
 							if (err) return continueCallback(err);
 							continueCallback();
 						});
@@ -837,7 +938,9 @@ class NormalModuleFactory extends ModuleFactory {
 				}
 
 				// resource without scheme and without path
-				else defaultResolve(context);
+				else {
+					defaultResolve(context);
+				}
 			}
 		);
 	}
@@ -852,7 +955,7 @@ class NormalModuleFactory extends ModuleFactory {
 
 	/**
 	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function((Error | null)=, ModuleFactoryResult=): void} callback callback
+	 * @param {ModuleFactoryCallback} callback callback
 	 * @returns {void}
 	 */
 	create(data, callback) {
@@ -861,20 +964,21 @@ class NormalModuleFactory extends ModuleFactory {
 		const resolveOptions = data.resolveOptions || EMPTY_RESOLVE_OPTIONS;
 		const dependency = dependencies[0];
 		const request = dependency.request;
-		const assertions = dependency.assertions;
+		const attributes =
+			/** @type {ModuleDependency & { attributes: ImportAttributes }} */
+			(dependency).attributes;
+		const dependencyType = dependency.category || "";
 		const contextInfo = data.contextInfo;
 		const fileDependencies = new LazySet();
 		const missingDependencies = new LazySet();
 		const contextDependencies = new LazySet();
-		const dependencyType =
-			(dependencies.length > 0 && dependencies[0].category) || "";
 		/** @type {ResolveData} */
 		const resolveData = {
 			contextInfo,
 			resolveOptions,
 			context,
 			request,
-			assertions,
+			attributes,
 			dependencies,
 			dependencyType,
 			fileDependencies,
@@ -910,13 +1014,14 @@ class NormalModuleFactory extends ModuleFactory {
 				return callback(null, factoryResult);
 			}
 
-			if (typeof result === "object")
+			if (typeof result === "object") {
 				throw new Error(
 					deprecationChangedHookMessage(
 						"beforeResolve",
 						this.hooks.beforeResolve
 					)
 				);
+			}
 
 			this.hooks.factorize.callAsync(resolveData, (err, module) => {
 				if (err) {
@@ -989,16 +1094,16 @@ ${hints.join("\n\n")}`;
 
 							// Check if the extension is missing a leading dot (e.g. "js" instead of ".js")
 							let appendResolveExtensionsHint = false;
-							const specifiedExtensions = Array.from(
-								resolver.options.extensions
-							);
-							const expectedExtensions = specifiedExtensions.map(extension => {
-								if (LEADING_DOT_EXTENSION_REGEX.test(extension)) {
-									appendResolveExtensionsHint = true;
-									return `.${extension}`;
+							const specifiedExtensions = [...resolver.options.extensions];
+							const expectedExtensions = specifiedExtensions.map(
+								(extension) => {
+									if (LEADING_DOT_EXTENSION_REGEX.test(extension)) {
+										appendResolveExtensionsHint = true;
+										return `.${extension}`;
+									}
+									return extension;
 								}
-								return extension;
-							});
+							);
 							if (appendResolveExtensionsHint) {
 								err.message += `\nDid you miss the leading dot in 'resolve.extensions'? Did you mean '${JSON.stringify(
 									expectedExtensions
@@ -1035,7 +1140,7 @@ ${hints.join("\n\n")}`;
 	) {
 		asyncLib.parallel(
 			[
-				callback => {
+				(callback) => {
 					if (!resolver.options.fullySpecified) return callback();
 					resolver
 						.withOptions({
@@ -1065,7 +1170,7 @@ Add the extension to the request.`
 							}
 						);
 				},
-				callback => {
+				(callback) => {
 					if (!resolver.options.enforceExtension) return callback();
 					resolver
 						.withOptions({
@@ -1104,7 +1209,7 @@ Including the extension in the request is no longer possible. Did you mean to en
 							}
 						);
 				},
-				callback => {
+				(callback) => {
 					if (
 						/^\.\.?\//.test(unresolvedResource) ||
 						resolver.options.preferRelative
@@ -1119,7 +1224,7 @@ Including the extension in the request is no longer possible. Did you mean to en
 						(err, resolvedResource) => {
 							if (err || !resolvedResource) return callback();
 							const moduleDirectories = resolver.options.modules
-								.map(m => (Array.isArray(m) ? m.join(", ") : m))
+								.map((m) => (Array.isArray(m) ? m.join(", ") : m))
 								.join(", ");
 							callback(
 								null,
@@ -1160,6 +1265,10 @@ If changing the source code is not an option there is also a resolve options cal
 		if (array.length === 0) return callback(null, array);
 		asyncLib.map(
 			array,
+			/**
+			 * @param {LoaderItem} item item
+			 * @param {Callback<LoaderItem>} callback callback
+			 */
 			(item, callback) => {
 				resolver.resolve(
 					contextInfo,
@@ -1177,7 +1286,7 @@ If changing the source code is not an option there is also a resolve options cal
 								context,
 								`${item.loader}-loader`,
 								resolveContext,
-								err2 => {
+								(err2) => {
 									if (!err2) {
 										err.message =
 											`${err.message}\n` +
@@ -1192,7 +1301,8 @@ If changing the source code is not an option there is also a resolve options cal
 						if (err) return callback(err);
 
 						const parsedResult = this._parseResourceWithoutFragment(
-							/** @type {string} */ (result)
+							/** @type {string} */
+							(result)
 						);
 
 						const type = /\.mjs$/i.test(parsedResult.path)
@@ -1202,8 +1312,12 @@ If changing the source code is not an option there is also a resolve options cal
 								: /** @type {ResolveRequest} */
 									(resolveRequest).descriptionFileData === undefined
 									? undefined
-									: /** @type {ResolveRequest} */
-										(resolveRequest).descriptionFileData.type;
+									: /** @type {string} */
+										(
+											/** @type {ResolveRequest} */
+											(resolveRequest).descriptionFileData.type
+										);
+						/** @type {LoaderItem} */
 						const resolved = {
 							loader: parsedResult.path,
 							type,
@@ -1213,17 +1327,16 @@ If changing the source code is not an option there is also a resolve options cal
 										? parsedResult.query.slice(1)
 										: undefined
 									: item.options,
-							ident:
-								item.options === undefined
-									? undefined
-									: /** @type {string} */ (item.ident)
+							ident: item.options === undefined ? undefined : item.ident
 						};
 
-						return callback(null, /** @type {LoaderItem} */ (resolved));
+						return callback(null, resolved);
 					}
 				);
 			},
-			/** @type {Callback<TODO>} */ (callback)
+			(err, value) => {
+				callback(err, /** @type {(LoaderItem)[]} */ (value));
+			}
 		);
 	}