webpack 5.97.1 → 5.104.1

package/lib/NormalModule.js

@@ -5,10 +5,15 @@
 
 "use strict";
 
+const querystring = require("querystring");
 const parseJson = require("json-parse-even-better-errors");
 const { getContext, runLoaders } = require("loader-runner");
-const querystring = require("querystring");
-const { HookMap, SyncHook, AsyncSeriesBailHook } = require("tapable");
+const {
+	AsyncSeriesBailHook,
+	HookMap,
+	SyncHook,
+	SyncWaterfallHook
+} = require("tapable");
 const {
 	CachedSource,
 	OriginalSource,
@@ -33,66 +38,72 @@ const { isSubset } = require("./util/SetHelpers");
 const { getScheme } = require("./util/URLAbsoluteSpecifier");
 const {
 	compareLocations,
-	concatComparators,
 	compareSelect,
-	keepOriginalOrder
+	concatComparators,
+	keepOriginalOrder,
+	sortWithSourceOrder
 } = require("./util/comparators");
 const createHash = require("./util/createHash");
 const { createFakeHook } = require("./util/deprecation");
 const { join } = require("./util/fs");
 const {
-	contextify,
 	absolutify,
+	contextify,
 	makePathsRelative
 } = require("./util/identifier");
 const makeSerializable = require("./util/makeSerializable");
 const memoize = require("./util/memoize");
 
+/** @typedef {import("enhanced-resolve").ResolveContext} ResolveContext */
+/** @typedef {import("enhanced-resolve").ResolveRequest} ResolveRequest */
 /** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").Mode} Mode */
+/** @typedef {import("webpack-sources").RawSourceMap} RawSourceMap */
 /** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("../declarations/WebpackOptions").NoParse} NoParse */
+/** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
 /** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("./Generator")} Generator */
+/** @typedef {import("./Generator").GenerateErrorFn} GenerateErrorFn */
 /** @typedef {import("./Module").BuildInfo} BuildInfo */
+/** @typedef {import("./Module").FileSystemDependencies} FileSystemDependencies */
 /** @typedef {import("./Module").BuildMeta} BuildMeta */
 /** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("./Module").CodeGenerationResultData} CodeGenerationResultData */
 /** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
 /** @typedef {import("./Module").KnownBuildInfo} KnownBuildInfo */
 /** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("./Module").LibIdent} LibIdent */
+/** @typedef {import("./Module").NameForCondition} NameForCondition */
 /** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("./Generator").SourceTypes} SourceTypes */
+/** @typedef {import("./Module").NeedBuildCallback} NeedBuildCallback */
+/** @typedef {import("./Module").BuildCallback} BuildCallback */
+/** @typedef {import("./Module").RuntimeRequirements} RuntimeRequirements */
+/** @typedef {import("./Module").SourceType} SourceType */
+/** @typedef {import("./Module").SourceTypes} SourceTypes */
 /** @typedef {import("./Module").UnsafeCacheData} UnsafeCacheData */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("./ModuleTypeConstants").JavaScriptModuleTypes} JavaScriptModuleTypes */
 /** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
-/** @typedef {import("./NormalModuleFactory").ResourceDataWithData} ResourceDataWithData */
+/** @typedef {import("./NormalModuleFactory").NormalModuleTypes} NormalModuleTypes */
+/** @typedef {import("./NormalModuleFactory").ResourceSchemeData} ResourceSchemeData */
 /** @typedef {import("./Parser")} Parser */
+/** @typedef {import("./Parser").PreparsedAst} PreparsedAst */
 /** @typedef {import("./RequestShortener")} RequestShortener */
-/** @typedef {import("./ResolverFactory").ResolveContext} ResolveContext */
 /** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./logging/Logger").Logger} WebpackLogger */
 /** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("./util/Hash")} Hash */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
-/** @typedef {import("./util/createHash").Algorithm} Algorithm */
+/** @typedef {import("../declarations/WebpackOptions").HashFunction} HashFunction */
+/** @typedef {import("./util/identifier").AssociatedObjectForCache} AssociatedObjectForCache */
 /**
  * @template T
  * @typedef {import("./util/deprecation").FakeHook<T>} FakeHook
  */
 
-/** @typedef {{[k: string]: any}} ParserOptions */
-/** @typedef {{[k: string]: any}} GeneratorOptions */
-
-/** @typedef {UnsafeCacheData & { parser: undefined | Parser, parserOptions: undefined | ParserOptions, generator: undefined | Generator, generatorOptions: undefined | GeneratorOptions }} NormalModuleUnsafeCacheData */
+/** @typedef {{ [k: string]: EXPECTED_ANY }} ParserOptions */
+/** @typedef {{ [k: string]: EXPECTED_ANY }} GeneratorOptions */
 
 /**
  * @template T
@@ -104,21 +115,12 @@ const memoize = require("./util/memoize");
  * @typedef {import("../declarations/LoaderContext").NormalModuleLoaderContext<T>} NormalModuleLoaderContext
  */
 
-/**
- * @typedef {object} SourceMap
- * @property {number} version
- * @property {string[]} sources
- * @property {string} mappings
- * @property {string=} file
- * @property {string=} sourceRoot
- * @property {string[]=} sourcesContent
- * @property {string[]=} names
- * @property {string=} debugId
- */
-
 const getInvalidDependenciesModuleWarning = memoize(() =>
 	require("./InvalidDependenciesModuleWarning")
 );
+
+const getExtractSourceMap = memoize(() => require("./util/extractSourceMap"));
+
 const getValidate = memoize(() => require("schema-utils").validate);
 
 const ABSOLUTE_PATH_REGEX = /^([a-zA-Z]:\\|\\\\|\/)/;
@@ -126,15 +128,15 @@ const ABSOLUTE_PATH_REGEX = /^([a-zA-Z]:\\|\\\\|\/)/;
 /**
  * @typedef {object} LoaderItem
  * @property {string} loader
- * @property {any} options
- * @property {string?} ident
- * @property {string?} type
+ * @property {string | null | undefined | Record<string, EXPECTED_ANY>} options
+ * @property {string | null=} ident
+ * @property {string | null=} type
  */
 
 /**
  * @param {string} context absolute context path
  * @param {string} source a source path
- * @param {object=} associatedObjectForCache an object to which the cache will be attached
+ * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} new source path
  */
 const contextifySourceUrl = (context, source, associatedObjectForCache) => {
@@ -148,26 +150,28 @@ const contextifySourceUrl = (context, source, associatedObjectForCache) => {
 
 /**
  * @param {string} context absolute context path
- * @param {SourceMap} sourceMap a source map
- * @param {object=} associatedObjectForCache an object to which the cache will be attached
- * @returns {SourceMap} new source map
+ * @param {string | RawSourceMap} sourceMap a source map
+ * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached
+ * @returns {string | RawSourceMap} new source map
  */
 const contextifySourceMap = (context, sourceMap, associatedObjectForCache) => {
-	if (!Array.isArray(sourceMap.sources)) return sourceMap;
+	if (typeof sourceMap === "string" || !Array.isArray(sourceMap.sources)) {
+		return sourceMap;
+	}
 	const { sourceRoot } = sourceMap;
-	/** @type {function(string): string} */
+	/** @type {(source: string) => string} */
 	const mapper = !sourceRoot
-		? source => source
+		? (source) => source
 		: sourceRoot.endsWith("/")
-			? source =>
+			? (source) =>
 					source.startsWith("/")
 						? `${sourceRoot.slice(0, -1)}${source}`
 						: `${sourceRoot}${source}`
-			: source =>
+			: (source) =>
 					source.startsWith("/")
 						? `${sourceRoot}${source}`
 						: `${sourceRoot}/${source}`;
-	const newSources = sourceMap.sources.map(source =>
+	const newSources = sourceMap.sources.map((source) =>
 		contextifySourceUrl(context, mapper(source), associatedObjectForCache)
 	);
 	return {
@@ -182,9 +186,9 @@ const contextifySourceMap = (context, sourceMap, associatedObjectForCache) => {
  * @param {string | Buffer} input the input
  * @returns {string} the converted string
  */
-const asString = input => {
+const asString = (input) => {
 	if (Buffer.isBuffer(input)) {
-		return input.toString("utf-8");
+		return input.toString("utf8");
 	}
 	return input;
 };
@@ -193,16 +197,16 @@ const asString = input => {
  * @param {string | Buffer} input the input
  * @returns {Buffer} the converted buffer
  */
-const asBuffer = input => {
+const asBuffer = (input) => {
 	if (!Buffer.isBuffer(input)) {
-		return Buffer.from(input, "utf-8");
+		return Buffer.from(input, "utf8");
 	}
 	return input;
 };
 
 class NonErrorEmittedError extends WebpackError {
 	/**
-	 * @param {any} error value which is not an instance of Error
+	 * @param {EXPECTED_ANY} error value which is not an instance of Error
 	 */
 	constructor(error) {
 		super();
@@ -218,27 +222,32 @@ makeSerializable(
 	"NonErrorEmittedError"
 );
 
+/** @typedef {[string | Buffer, string | RawSourceMap | undefined, PreparsedAst | undefined]}  Result */
+
+/** @typedef {LoaderContext<EXPECTED_ANY>} AnyLoaderContext */
+
 /**
  * @typedef {object} NormalModuleCompilationHooks
- * @property {SyncHook<[LoaderContext<any>, NormalModule]>} loader
- * @property {SyncHook<[LoaderItem[], NormalModule, LoaderContext<any>]>} beforeLoaders
+ * @property {SyncHook<[AnyLoaderContext, NormalModule]>} loader
+ * @property {SyncHook<[LoaderItem[], NormalModule, AnyLoaderContext]>} beforeLoaders
  * @property {SyncHook<[NormalModule]>} beforeParse
  * @property {SyncHook<[NormalModule]>} beforeSnapshot
  * @property {HookMap<FakeHook<AsyncSeriesBailHook<[string, NormalModule], string | Buffer | null>>>} readResourceForScheme
- * @property {HookMap<AsyncSeriesBailHook<[LoaderContext<any>], string | Buffer | null>>} readResource
+ * @property {HookMap<AsyncSeriesBailHook<[AnyLoaderContext], string | Buffer | null>>} readResource
+ * @property {SyncWaterfallHook<[Result, NormalModule]>} processResult
  * @property {AsyncSeriesBailHook<[NormalModule, NeedBuildContext], boolean>} needBuild
  */
 
 /**
  * @typedef {object} NormalModuleCreateData
  * @property {string=} layer an optional layer in which the module is
- * @property {JavaScriptModuleTypes | ""} type module type. When deserializing, this is set to an empty string "".
+ * @property {NormalModuleTypes | ""} type module type. When deserializing, this is set to an empty string "".
  * @property {string} request request string
  * @property {string} userRequest request intended by user (without loaders from config)
  * @property {string} rawRequest request without resolving
  * @property {LoaderItem[]} loaders list of loaders
  * @property {string} resource path + query of the real resource
- * @property {Record<string, any>=} resourceResolveData resource resolve data
+ * @property {(ResourceSchemeData & Partial<ResolveRequest>)=} resourceResolveData resource resolve data
  * @property {string} context context directory for resolving
  * @property {string=} matchResource path + query of the matched resource (virtual)
  * @property {Parser} parser the parser used
@@ -246,6 +255,11 @@ makeSerializable(
  * @property {Generator} generator the generator used
  * @property {GeneratorOptions=} generatorOptions the options of the generator used
  * @property {ResolveOptions=} resolveOptions options used for resolving requests from this module
+ * @property {boolean} extractSourceMap enable/disable extracting source map
+ */
+
+/**
+ * @typedef {(resourcePath: string, getLoaderContext: (resourcePath: string) => AnyLoaderContext) => Promise<string | Buffer<ArrayBufferLike>>} ReadResource
  */
 
 /** @type {WeakMap<Compilation, NormalModuleCompilationHooks>} */
@@ -270,14 +284,14 @@ class NormalModule extends Module {
 				beforeParse: new SyncHook(["module"]),
 				beforeSnapshot: new SyncHook(["module"]),
 				// TODO webpack 6 deprecate
-				readResourceForScheme: new HookMap(scheme => {
+				readResourceForScheme: new HookMap((scheme) => {
 					const hook =
 						/** @type {NormalModuleCompilationHooks} */
 						(hooks).readResource.for(scheme);
 					return createFakeHook(
 						/** @type {AsyncSeriesBailHook<[string, NormalModule], string | Buffer | null>} */ ({
 							tap: (options, fn) =>
-								hook.tap(options, loaderContext =>
+								hook.tap(options, (loaderContext) =>
 									fn(
 										loaderContext.resource,
 										/** @type {NormalModule} */ (loaderContext._module)
@@ -292,7 +306,7 @@ class NormalModule extends Module {
 									)
 								),
 							tapPromise: (options, fn) =>
-								hook.tapPromise(options, loaderContext =>
+								hook.tapPromise(options, (loaderContext) =>
 									fn(
 										loaderContext.resource,
 										/** @type {NormalModule} */ (loaderContext._module)
@@ -304,6 +318,7 @@ class NormalModule extends Module {
 				readResource: new HookMap(
 					() => new AsyncSeriesBailHook(["loaderContext"])
 				),
+				processResult: new SyncWaterfallHook(["result", "module"]),
 				needBuild: new AsyncSeriesBailHook(["module", "context"])
 			};
 			compilationHooksMap.set(
@@ -332,38 +347,43 @@ class NormalModule extends Module {
 		parserOptions,
 		generator,
 		generatorOptions,
-		resolveOptions
+		resolveOptions,
+		extractSourceMap
 	}) {
 		super(type, context || getContext(resource), layer);
 
 		// Info from Factory
-		/** @type {string} */
+		/** @type {NormalModuleCreateData['request']} */
 		this.request = request;
-		/** @type {string} */
+		/** @type {NormalModuleCreateData['userRequest']} */
 		this.userRequest = userRequest;
-		/** @type {string} */
+		/** @type {NormalModuleCreateData['rawRequest']} */
 		this.rawRequest = rawRequest;
 		/** @type {boolean} */
 		this.binary = /^(asset|webassembly)\b/.test(type);
-		/** @type {undefined | Parser} */
+		/** @type {NormalModuleCreateData['parser'] | undefined} */
 		this.parser = parser;
-		/** @type {undefined | ParserOptions} */
+		/** @type {NormalModuleCreateData['parserOptions']} */
 		this.parserOptions = parserOptions;
-		/** @type {undefined | Generator} */
+		/** @type {NormalModuleCreateData['generator'] | undefined} */
 		this.generator = generator;
-		/** @type {undefined | GeneratorOptions} */
+		/** @type {NormalModuleCreateData['generatorOptions']} */
 		this.generatorOptions = generatorOptions;
-		/** @type {string} */
+		/** @type {NormalModuleCreateData['resource']} */
 		this.resource = resource;
+		/** @type {NormalModuleCreateData['resourceResolveData']} */
 		this.resourceResolveData = resourceResolveData;
-		/** @type {string | undefined} */
+		/** @type {NormalModuleCreateData['matchResource']} */
 		this.matchResource = matchResource;
-		/** @type {LoaderItem[]} */
+		/** @type {NormalModuleCreateData['loaders']} */
 		this.loaders = loaders;
 		if (resolveOptions !== undefined) {
 			// already declared in super class
+			/** @type {NormalModuleCreateData['resolveOptions']} */
 			this.resolveOptions = resolveOptions;
 		}
+		/** @type {NormalModuleCreateData['extractSourceMap']} */
+		this.extractSourceMap = extractSourceMap;
 
 		// Info from Build
 		/** @type {WebpackError | null} */
@@ -375,7 +395,7 @@ class NormalModule extends Module {
 		this._source = null;
 		/**
 		 * @private
-		 * @type {Map<string | undefined, number> | undefined}
+		 * @type {Map<undefined | SourceType, number> | undefined}
 		 */
 		this._sourceSizes = undefined;
 		/**
@@ -390,7 +410,7 @@ class NormalModule extends Module {
 		this._isEvaluatingSideEffects = false;
 		/** @type {WeakSet<ModuleGraph> | undefined} */
 		this._addedSideEffectsBailout = undefined;
-		/** @type {Map<string, any>} */
+		/** @type {CodeGenerationResultData} */
 		this._codeGeneratorData = new Map();
 	}
 
@@ -415,9 +435,16 @@ class NormalModule extends Module {
 		return /** @type {string} */ (requestShortener.shorten(this.userRequest));
 	}
 
+	/**
+	 * @returns {string | null} return the resource path
+	 */
+	getResource() {
+		return this.matchResource || this.resource;
+	}
+
 	/**
 	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
+	 * @returns {LibIdent | null} an identifier for library inclusion
 	 */
 	libIdent(options) {
 		let ident = contextify(
@@ -430,10 +457,10 @@ class NormalModule extends Module {
 	}
 
 	/**
-	 * @returns {string | null} absolute path which should be used for condition matching (usually the resource path)
+	 * @returns {NameForCondition | null} absolute path which should be used for condition matching (usually the resource path)
 	 */
 	nameForCondition() {
-		const resource = this.matchResource || this.resource;
+		const resource = /** @type {string} */ (this.getResource());
 		const idx = resource.indexOf("?");
 		if (idx >= 0) return resource.slice(0, idx);
 		return resource;
@@ -462,6 +489,7 @@ class NormalModule extends Module {
 		this.context = m.context;
 		this.matchResource = m.matchResource;
 		this.loaders = m.loaders;
+		this.extractSourceMap = m.extractSourceMap;
 	}
 
 	/**
@@ -490,9 +518,7 @@ class NormalModule extends Module {
 	 * @returns {UnsafeCacheData} cached data
 	 */
 	getUnsafeCacheData() {
-		const data =
-			/** @type {NormalModuleUnsafeCacheData} */
-			(super.getUnsafeCacheData());
+		const data = super.getUnsafeCacheData();
 		data.parserOptions = this.parserOptions;
 		data.generatorOptions = this.generatorOptions;
 		return data;
@@ -500,7 +526,7 @@ class NormalModule extends Module {
 
 	/**
 	 * restore unsafe cache data
-	 * @param {NormalModuleUnsafeCacheData} unsafeCacheData data from getUnsafeCacheData
+	 * @param {UnsafeCacheData} unsafeCacheData data from getUnsafeCacheData
 	 * @param {NormalModuleFactory} normalModuleFactory the normal module factory handling the unsafe caching
 	 */
 	restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) {
@@ -509,7 +535,7 @@ class NormalModule 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) {
@@ -528,8 +554,8 @@ class NormalModule extends Module {
 	 * @param {string} context the compilation context
 	 * @param {string} name the asset name
 	 * @param {string | Buffer} content the content
-	 * @param {(string | SourceMap)=} sourceMap an optional source map
-	 * @param {object=} associatedObjectForCache object for caching
+	 * @param {(string | RawSourceMap)=} sourceMap an optional source map
+	 * @param {AssociatedObjectForCache=} associatedObjectForCache object for caching
 	 * @returns {Source} the created source
 	 */
 	createSourceForAsset(
@@ -556,7 +582,8 @@ class NormalModule extends Module {
 					name,
 					contextifySourceMap(
 						context,
-						/** @type {SourceMap} */ (sourceMap),
+						/** @type {RawSourceMap} */
+						(sourceMap),
 						associatedObjectForCache
 					)
 				);
@@ -574,12 +601,15 @@ class NormalModule extends Module {
 	 * @param {Compilation} compilation the compilation
 	 * @param {InputFileSystem} fs file system from reading
 	 * @param {NormalModuleCompilationHooks} hooks the hooks
-	 * @returns {import("../declarations/LoaderContext").NormalModuleLoaderContext<T>} loader context
+	 * @returns {import("../declarations/LoaderContext").LoaderContext<T>} loader context
 	 */
 	_createLoaderContext(resolver, options, compilation, fs, hooks) {
 		const { requestShortener } = compilation.runtimeTemplate;
 		const getCurrentLoaderName = () => {
-			const currentLoader = this.getCurrentLoader(loaderContext);
+			const currentLoader = this.getCurrentLoader(
+				/** @type {AnyLoaderContext} */
+				(loaderContext)
+			);
 			if (!currentLoader) return "(not in loader scope)";
 			return requestShortener.shorten(currentLoader.loader);
 		};
@@ -588,13 +618,19 @@ class NormalModule extends Module {
 		 */
 		const getResolveContext = () => ({
 			fileDependencies: {
-				add: d => /** @type {TODO} */ (loaderContext).addDependency(d)
+				add: (d) =>
+					/** @type {AnyLoaderContext} */
+					(loaderContext).addDependency(d)
 			},
 			contextDependencies: {
-				add: d => /** @type {TODO} */ (loaderContext).addContextDependency(d)
+				add: (d) =>
+					/** @type {AnyLoaderContext} */
+					(loaderContext).addContextDependency(d)
 			},
 			missingDependencies: {
-				add: d => /** @type {TODO} */ (loaderContext).addMissingDependency(d)
+				add: (d) =>
+					/** @type {AnyLoaderContext} */
+					(loaderContext).addMissingDependency(d)
 			}
 		});
 		const getAbsolutify = memoize(() =>
@@ -637,21 +673,24 @@ class NormalModule extends Module {
 					? getContextifyInContext()(request)
 					: getContextify()(context, request),
 			/**
-			 * @param {(string | typeof import("./util/Hash"))=} type type
+			 * @param {HashFunction=} type type
 			 * @returns {Hash} hash
 			 */
-			createHash: type =>
-				createHash(
-					type ||
-						/** @type {Algorithm} */
-						(compilation.outputOptions.hashFunction)
-				)
+			createHash: (type) =>
+				createHash(type || compilation.outputOptions.hashFunction)
 		};
-		/** @type {import("../declarations/LoaderContext").NormalModuleLoaderContext<T>} */
+		/** @type {NormalModuleLoaderContext<T>} */
 		const loaderContext = {
 			version: 2,
-			getOptions: schema => {
-				const loader = this.getCurrentLoader(loaderContext);
+			/**
+			 * @param {import("../declarations/LoaderContext").Schema=} schema schema
+			 * @returns {T} options
+			 */
+			getOptions: (schema) => {
+				const loader = this.getCurrentLoader(
+					/** @type {AnyLoaderContext} */
+					(loaderContext)
+				);
 
 				let { options } = /** @type {LoaderItem} */ (loader);
 
@@ -661,7 +700,8 @@ class NormalModule extends Module {
 							options = parseJson(options);
 						} catch (err) {
 							throw new Error(
-								`Cannot parse string options: ${/** @type {Error} */ (err).message}`
+								`Cannot parse string options: ${/** @type {Error} */ (err).message}`,
+								{ cause: err }
 							);
 						}
 					} else {
@@ -682,15 +722,15 @@ class NormalModule extends Module {
 					if (schema.title && (match = /^(.+) (.+)$/.exec(schema.title))) {
 						[, name, baseDataPath] = match;
 					}
-					getValidate()(schema, options, {
+					getValidate()(schema, /** @type {EXPECTED_OBJECT} */ (options), {
 						name,
 						baseDataPath
 					});
 				}
 
-				return options;
+				return /** @type {T} */ (options);
 			},
-			emitWarning: warning => {
+			emitWarning: (warning) => {
 				if (!(warning instanceof Error)) {
 					warning = new NonErrorEmittedError(warning);
 				}
@@ -700,7 +740,7 @@ class NormalModule extends Module {
 					})
 				);
 			},
-			emitError: error => {
+			emitError: (error) => {
 				if (!(error instanceof Error)) {
 					error = new NonErrorEmittedError(error);
 				}
@@ -710,8 +750,11 @@ class NormalModule extends Module {
 					})
 				);
 			},
-			getLogger: name => {
-				const currentLoader = this.getCurrentLoader(loaderContext);
+			getLogger: (name) => {
+				const currentLoader = this.getCurrentLoader(
+					/** @type {AnyLoaderContext} */
+					(loaderContext)
+				);
 				return compilation.getLogger(() =>
 					[currentLoader && currentLoader.loader, name, this.identifier()]
 						.filter(Boolean)
@@ -723,24 +766,32 @@ class NormalModule extends Module {
 			},
 			getResolve(options) {
 				const child = options ? resolver.withOptions(options) : resolver;
-				return (context, request, callback) => {
-					if (callback) {
-						child.resolve({}, context, request, getResolveContext(), callback);
-					} else {
-						return new Promise((resolve, reject) => {
+				return /** @type {ReturnType<import("../declarations/LoaderContext").NormalModuleLoaderContext<T>["getResolve"]>} */ (
+					(context, request, callback) => {
+						if (callback) {
 							child.resolve(
 								{},
 								context,
 								request,
 								getResolveContext(),
-								(err, result) => {
-									if (err) reject(err);
-									else resolve(result);
-								}
+								callback
 							);
-						});
+						} else {
+							return new Promise((resolve, reject) => {
+								child.resolve(
+									{},
+									context,
+									request,
+									getResolveContext(),
+									(err, result) => {
+										if (err) reject(err);
+										else resolve(result);
+									}
+								);
+							});
+						}
 					}
-				};
+				);
 			},
 			emitFile: (name, content, sourceMap, assetInfo) => {
 				const buildInfo = /** @type {BuildInfo} */ (this.buildInfo);
@@ -758,7 +809,7 @@ class NormalModule extends Module {
 					(buildInfo.assetsInfo);
 
 				assets[name] = this.createSourceForAsset(
-					/** @type {string} */ (options.context),
+					options.context,
 					name,
 					content,
 					sourceMap,
@@ -766,7 +817,7 @@ class NormalModule extends Module {
 				);
 				assetsInfo.set(name, assetInfo);
 			},
-			addBuildDependency: dep => {
+			addBuildDependency: (dep) => {
 				const buildInfo = /** @type {BuildInfo} */ (this.buildInfo);
 
 				if (buildInfo.buildDependencies === undefined) {
@@ -775,14 +826,14 @@ class NormalModule extends Module {
 				buildInfo.buildDependencies.add(dep);
 			},
 			utils,
-			rootContext: /** @type {string} */ (options.context),
+			rootContext: options.context,
 			webpack: true,
 			sourceMap: Boolean(this.useSourceMap),
 			mode: options.mode || "production",
-			hashFunction: /** @type {TODO} */ (options.output.hashFunction),
-			hashDigest: /** @type {string} */ (options.output.hashDigest),
-			hashDigestLength: /** @type {number} */ (options.output.hashDigestLength),
-			hashSalt: /** @type {string} */ (options.output.hashSalt),
+			hashFunction: options.output.hashFunction,
+			hashDigest: options.output.hashDigest,
+			hashDigestLength: options.output.hashDigestLength,
+			hashSalt: options.output.hashSalt,
 			_module: this,
 			_compilation: compilation,
 			_compiler: compilation.compiler,
@@ -791,14 +842,18 @@ class NormalModule extends Module {
 
 		Object.assign(loaderContext, options.loader);
 
-		hooks.loader.call(/** @type {LoaderContext<any>} */ (loaderContext), this);
+		hooks.loader.call(
+			/** @type {AnyLoaderContext} */
+			(loaderContext),
+			this
+		);
 
-		return loaderContext;
+		return /** @type {AnyLoaderContext} */ (loaderContext);
 	}
 
 	// TODO remove `loaderContext` in webpack@6
 	/**
-	 * @param {TODO} loaderContext loader context
+	 * @param {AnyLoaderContext} loaderContext loader context
 	 * @param {number} index index
 	 * @returns {LoaderItem | null} loader
 	 */
@@ -818,8 +873,8 @@ class NormalModule extends Module {
 	/**
 	 * @param {string} context the compilation context
 	 * @param {string | Buffer} content the content
-	 * @param {(string | SourceMapSource | null)=} sourceMap an optional source map
-	 * @param {object=} associatedObjectForCache object for caching
+	 * @param {(string | RawSourceMap | null)=} sourceMap an optional source map
+	 * @param {AssociatedObjectForCache=} associatedObjectForCache object for caching
 	 * @returns {Source} the created source
 	 */
 	createSource(context, content, sourceMap, associatedObjectForCache) {
@@ -839,11 +894,7 @@ class NormalModule extends Module {
 			return new SourceMapSource(
 				content,
 				contextifySourceUrl(context, identifier, associatedObjectForCache),
-				contextifySourceMap(
-					context,
-					/** @type {TODO} */ (sourceMap),
-					associatedObjectForCache
-				)
+				contextifySourceMap(context, sourceMap, associatedObjectForCache)
 			);
 		}
 
@@ -863,7 +914,7 @@ class NormalModule extends Module {
 	 * @param {ResolverWithOptions} resolver the resolver
 	 * @param {InputFileSystem} fs the file system
 	 * @param {NormalModuleCompilationHooks} hooks the hooks
-	 * @param {function((WebpackError | null)=): void} callback callback function
+	 * @param {BuildCallback} callback callback function
 	 * @returns {void}
 	 */
 	_doBuild(options, compilation, resolver, fs, hooks, callback) {
@@ -875,14 +926,12 @@ class NormalModule extends Module {
 			hooks
 		);
 
-		/** @typedef {[string | Buffer, string | SourceMapSource, Record<string, any>]}  Result */
-
 		/**
 		 * @param {Error | null} err err
-		 * @param {(Result | null)=} _result result
+		 * @param {(Result | null)=} result_ result
 		 * @returns {void}
 		 */
-		const processResult = (err, _result) => {
+		const processResult = (err, result_) => {
 			if (err) {
 				if (!(err instanceof Error)) {
 					err = new NonErrorEmittedError(err);
@@ -897,8 +946,11 @@ class NormalModule extends Module {
 				});
 				return callback(error);
 			}
-
-			const result = /** @type {Result} */ (_result);
+			const result = hooks.processResult.call(
+				/** @type {Result} */
+				(result_),
+				this
+			);
 			const source = result[0];
 			const sourceMap = result.length >= 1 ? result[1] : null;
 			const extraInfo = result.length >= 2 ? result[2] : null;
@@ -924,7 +976,7 @@ class NormalModule extends Module {
 					: this.binary;
 
 			this._source = this.createSource(
-				/** @type {string} */ (options.context),
+				options.context,
 				isBinaryModule ? asBuffer(source) : asString(source),
 				sourceMap,
 				compilation.compiler.root
@@ -950,7 +1002,8 @@ class NormalModule extends Module {
 			hooks.beforeLoaders.call(
 				this.loaders,
 				this,
-				/** @type {LoaderContext<any>} */ (loaderContext)
+				/** @type {AnyLoaderContext} */
+				(loaderContext)
 			);
 		} catch (err) {
 			processResult(/** @type {Error} */ (err));
@@ -968,28 +1021,80 @@ class NormalModule extends Module {
 				loaders: this.loaders,
 				context: loaderContext,
 				/**
-				 * @param {LoaderContext<TODO>} loaderContext the loader context
+				 * @param {AnyLoaderContext} loaderContext the loader context
 				 * @param {string} resourcePath the resource Path
-				 * @param {(err: Error | null, result?: string | Buffer) => void} callback callback
+				 * @param {(err: Error | null, result?: string | Buffer, sourceMap?: Result[1]) => void} callback callback
+				 * @returns {Promise<void>}
 				 */
-				processResource: (loaderContext, resourcePath, callback) => {
-					const resource = loaderContext.resource;
-					const scheme = getScheme(resource);
-					hooks.readResource
-						.for(scheme)
-						.callAsync(loaderContext, (err, result) => {
-							if (err) return callback(err);
-							if (typeof result !== "string" && !result) {
-								return callback(
-									new UnhandledSchemeError(
-										/** @type {string} */
-										(scheme),
-										resource
-									)
+				processResource: async (loaderContext, resourcePath, callback) => {
+					/** @type {ReadResource} */
+					const readResource = (resourcePath, getLoaderContext) => {
+						const scheme = getScheme(resourcePath);
+						return new Promise((resolve, reject) => {
+							hooks.readResource
+								.for(scheme)
+								.callAsync(getLoaderContext(resourcePath), (err, result) => {
+									if (err) {
+										reject(err);
+									} else {
+										if (typeof result !== "string" && !result) {
+											return reject(
+												new UnhandledSchemeError(
+													/** @type {string} */
+													(scheme),
+													resourcePath
+												)
+											);
+										}
+										resolve(result);
+									}
+								});
+						});
+					};
+					try {
+						const result = await readResource(
+							resourcePath,
+							() => loaderContext
+						);
+						if (
+							this.extractSourceMap &&
+							(this.useSourceMap || this.useSimpleSourceMap)
+						) {
+							try {
+								const { source, sourceMap } = await getExtractSourceMap()(
+									result,
+									resourcePath,
+									/** @type {ReadResource} */
+									(resourcePath) =>
+										readResource(
+											resourcePath,
+											(resourcePath) =>
+												/** @type {AnyLoaderContext} */
+												({
+													addDependency(dependency) {
+														loaderContext.addDependency(dependency);
+													},
+													fs: loaderContext.fs,
+													_module: undefined,
+													resourcePath,
+													resource: resourcePath
+												})
+										).catch((err) => {
+											throw new Error(
+												`Failed to parse source map. ${/** @type {Error} */ (err).message}`
+											);
+										})
 								);
+								return callback(null, source, sourceMap);
+							} catch (err) {
+								this.addWarning(new ModuleWarning(/** @type {Error} */ (err)));
+								return callback(null, result);
 							}
-							return callback(null, result);
-						});
+						}
+						return callback(null, result);
+					} catch (error) {
+						return callback(/** @type {Error} */ (error));
+					}
 				}
 			},
 			(err, result) => {
@@ -997,10 +1102,9 @@ class NormalModule extends Module {
 				loaderContext._compilation =
 					loaderContext._compiler =
 					loaderContext._module =
-					// eslint-disable-next-line no-warning-comments
-					// @ts-ignore
 					loaderContext.fs =
-						undefined;
+						/** @type {EXPECTED_ANY} */
+						(undefined);
 
 				if (!result) {
 					/** @type {BuildInfo} */
@@ -1051,7 +1155,7 @@ class NormalModule extends Module {
 	}
 
 	/**
-	 * @param {TODO} rule rule
+	 * @param {Exclude<NoParse, EXPECTED_ANY[]>} rule rule
 	 * @param {string} content content
 	 * @returns {boolean} result
 	 */
@@ -1069,7 +1173,7 @@ class NormalModule extends Module {
 	}
 
 	/**
-	 * @param {TODO} noParseRule no parse rule
+	 * @param {undefined | NoParse} noParseRule no parse rule
 	 * @param {string} request request
 	 * @returns {boolean} check if module should not be parsed, returns "true" if the module should !not! be parsed, returns "false" if the module !must! be parsed
 	 */
@@ -1103,10 +1207,7 @@ class NormalModule extends Module {
 	 * @private
 	 */
 	_initBuildHash(compilation) {
-		const hash = createHash(
-			/** @type {Algorithm} */
-			(compilation.outputOptions.hashFunction)
-		);
+		const hash = createHash(compilation.outputOptions.hashFunction);
 		if (this._source) {
 			hash.update("source");
 			this._source.updateHash(hash);
@@ -1114,7 +1215,7 @@ class NormalModule extends Module {
 		hash.update("meta");
 		hash.update(JSON.stringify(this.buildMeta));
 		/** @type {BuildInfo} */
-		(this.buildInfo).hash = /** @type {string} */ (hash.digest("hex"));
+		(this.buildInfo).hash = hash.digest("hex");
 	}
 
 	/**
@@ -1122,7 +1223,7 @@ class NormalModule 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) {
@@ -1152,7 +1253,7 @@ class NormalModule extends Module {
 
 		const hooks = NormalModule.getCompilationHooks(compilation);
 
-		return this._doBuild(options, compilation, resolver, fs, hooks, err => {
+		return this._doBuild(options, compilation, resolver, fs, hooks, (err) => {
 			// if we have an error mark module as failed and exit
 			if (err) {
 				this.markModuleAsErrored(err);
@@ -1164,14 +1265,10 @@ class NormalModule extends Module {
 			 * @param {Error} e error
 			 * @returns {void}
 			 */
-			const handleParseError = e => {
+			const handleParseError = (e) => {
 				const source = /** @type {Source} */ (this._source).source();
-				const loaders = this.loaders.map(item =>
-					contextify(
-						/** @type {string} */ (options.context),
-						item.loader,
-						compilation.compiler.root
-					)
+				const loaders = this.loaders.map((item) =>
+					contextify(options.context, item.loader, compilation.compiler.root)
 				);
 				const error = new ModuleParseError(source, e, loaders, this.type);
 				this.markModuleAsErrored(error);
@@ -1182,10 +1279,11 @@ class NormalModule extends Module {
 			const handleParseResult = () => {
 				this.dependencies.sort(
 					concatComparators(
-						compareSelect(a => a.loc, compareLocations),
+						compareSelect((a) => a.loc, compareLocations),
 						keepOriginalOrder(this.dependencies)
 					)
 				);
+				sortWithSourceOrder(this.dependencies, new WeakMap());
 				this._initBuildHash(compilation);
 				this._lastSuccessfulBuildMeta =
 					/** @type {BuildMeta} */
@@ -1211,13 +1309,14 @@ class NormalModule extends Module {
 				/** @type {undefined | Set<string>} */
 				let nonAbsoluteDependencies;
 				/**
-				 * @param {LazySet<string>} deps deps
+				 * @param {FileSystemDependencies} deps deps
 				 */
-				const checkDependencies = deps => {
+				const checkDependencies = (deps) => {
 					for (const dep of deps) {
 						if (!ABSOLUTE_PATH_REGEX.test(dep)) {
-							if (nonAbsoluteDependencies === undefined)
+							if (nonAbsoluteDependencies === undefined) {
 								nonAbsoluteDependencies = new Set();
+							}
 							nonAbsoluteDependencies.add(dep);
 							deps.delete(dep);
 							try {
@@ -1232,8 +1331,8 @@ class NormalModule extends Module {
 									(depWithoutGlob !== dep
 										? /** @type {NonNullable<KnownBuildInfo["contextDependencies"]>} */
 											(
-												/** @type {BuildInfo} */ (this.buildInfo)
-													.contextDependencies
+												/** @type {BuildInfo} */
+												(this.buildInfo).contextDependencies
 											)
 										: deps
 									).add(absolute);
@@ -1342,8 +1441,9 @@ class NormalModule extends Module {
 			if (this.factoryMeta.sideEffectFree === false) return true;
 		}
 		if (this.buildMeta !== undefined && this.buildMeta.sideEffectFree) {
-			if (this._isEvaluatingSideEffects)
+			if (this._isEvaluatingSideEffects) {
 				return ModuleGraphConnection.CIRCULAR_CONNECTION;
+			}
 			this._isEvaluatingSideEffects = true;
 			/** @type {ConnectionState} */
 			let current = false;
@@ -1405,7 +1505,7 @@ class NormalModule extends Module {
 		codeGenerationResults,
 		sourceTypes
 	}) {
-		/** @type {Set<string>} */
+		/** @type {RuntimeRequirements} */
 		const runtimeRequirements = new Set();
 
 		const { parsed } = /** @type {BuildInfo} */ (this.buildInfo);
@@ -1416,16 +1516,32 @@ class NormalModule extends Module {
 			runtimeRequirements.add(RuntimeGlobals.thisAsExports);
 		}
 
-		/** @type {function(): Map<string, any>} */
 		const getData = () => this._codeGeneratorData;
 
 		const sources = new Map();
 		for (const type of sourceTypes || chunkGraph.getModuleSourceTypes(this)) {
+			// TODO webpack@6 make generateError required
+			const generator =
+				/** @type {Generator & { generateError?: GenerateErrorFn }} */
+				(this.generator);
 			const source = this.error
-				? new RawSource(
-						`throw new Error(${JSON.stringify(this.error.message)});`
-					)
-				: /** @type {Generator} */ (this.generator).generate(this, {
+				? generator.generateError
+					? generator.generateError(this.error, this, {
+							dependencyTemplates,
+							runtimeTemplate,
+							moduleGraph,
+							chunkGraph,
+							runtimeRequirements,
+							runtime,
+							concatenationScope,
+							codeGenerationResults,
+							getData,
+							type
+						})
+					: new RawSource(
+							`throw new Error(${JSON.stringify(this.error.message)});`
+						)
+				: generator.generate(this, {
 						dependencyTemplates,
 						runtimeTemplate,
 						moduleGraph,
@@ -1468,7 +1584,7 @@ class NormalModule 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) {
@@ -1547,10 +1663,10 @@ class NormalModule extends Module {
 	}
 
 	/**
-	 * @param {LazySet<string>} fileDependencies set where file dependencies are added to
-	 * @param {LazySet<string>} contextDependencies set where context dependencies are added to
-	 * @param {LazySet<string>} missingDependencies set where missing dependencies are added to
-	 * @param {LazySet<string>} buildDependencies set where build dependencies are added to
+	 * @param {FileSystemDependencies} fileDependencies set where file dependencies are added to
+	 * @param {FileSystemDependencies} contextDependencies set where context dependencies are added to
+	 * @param {FileSystemDependencies} missingDependencies set where missing dependencies are added to
+	 * @param {FileSystemDependencies} buildDependencies set where build dependencies are added to
 	 */
 	addCacheDependencies(
 		fileDependencies,
@@ -1585,7 +1701,11 @@ class NormalModule extends Module {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		hash.update(/** @type {BuildInfo} */ (this.buildInfo).hash);
+		const buildInfo = /** @type {BuildInfo} */ (this.buildInfo);
+		hash.update(
+			/** @type {string} */
+			(buildInfo.hash)
+		);
 		/** @type {Generator} */
 		(this.generator).updateHash(hash, {
 			module: this,
@@ -1610,7 +1730,7 @@ class NormalModule extends Module {
 
 	/**
 	 * @param {ObjectDeserializerContext} context context
-	 * @returns {TODO} Module
+	 * @returns {NormalModule} module
 	 */
 	static deserialize(context) {
 		const obj = new NormalModule({
@@ -1629,7 +1749,8 @@ class NormalModule extends Module {
 			parserOptions: /** @type {EXPECTED_ANY} */ (null),
 			generator: /** @type {EXPECTED_ANY} */ (null),
 			generatorOptions: /** @type {EXPECTED_ANY} */ (null),
-			resolveOptions: /** @type {EXPECTED_ANY} */ (null)
+			resolveOptions: /** @type {EXPECTED_ANY} */ (null),
+			extractSourceMap: /** @type {EXPECTED_ANY} */ (null)
 		});
 		obj.deserialize(context);
 		return obj;