webpack 5.59.0 → 5.94.0

package/lib/NormalModule.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const parseJson = require("json-parse-better-errors");
+const parseJson = require("json-parse-even-better-errors");
 const { getContext, runLoaders } = require("loader-runner");
 const querystring = require("querystring");
 const { HookMap, SyncHook, AsyncSeriesBailHook } = require("tapable");
@@ -22,6 +22,7 @@ const ModuleBuildError = require("./ModuleBuildError");
 const ModuleError = require("./ModuleError");
 const ModuleGraphConnection = require("./ModuleGraphConnection");
 const ModuleParseError = require("./ModuleParseError");
+const { JAVASCRIPT_MODULE_TYPE_AUTO } = require("./ModuleTypeConstants");
 const ModuleWarning = require("./ModuleWarning");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const UnhandledSchemeError = require("./UnhandledSchemeError");
@@ -48,33 +49,62 @@ const makeSerializable = require("./util/makeSerializable");
 const memoize = require("./util/memoize");
 
 /** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/LoaderContext").NormalModuleLoaderContext} NormalModuleLoaderContext */
 /** @typedef {import("../declarations/WebpackOptions").Mode} Mode */
+/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
 /** @typedef {import("./ChunkGraph")} ChunkGraph */
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("./DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("./Generator")} Generator */
+/** @typedef {import("./Module").BuildInfo} BuildInfo */
+/** @typedef {import("./Module").BuildMeta} BuildMeta */
 /** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
+/** @typedef {import("./Module").KnownBuildInfo} KnownBuildInfo */
 /** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
 /** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
+/** @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("./Parser")} Parser */
 /** @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 */
+/**
+ * @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 {Object} SourceMap
+ * @template T
+ * @typedef {import("../declarations/LoaderContext").LoaderContext<T>} LoaderContext
+ */
+
+/**
+ * @template T
+ * @typedef {import("../declarations/LoaderContext").NormalModuleLoaderContext<T>} NormalModuleLoaderContext
+ */
+
+/**
+ * @typedef {object} SourceMap
  * @property {number} version
  * @property {string[]} sources
  * @property {string} mappings
@@ -92,7 +122,7 @@ const getValidate = memoize(() => require("schema-utils").validate);
 const ABSOLUTE_PATH_REGEX = /^([a-zA-Z]:\\|\\\\|\/)/;
 
 /**
- * @typedef {Object} LoaderItem
+ * @typedef {object} LoaderItem
  * @property {string} loader
  * @property {any} options
  * @property {string?} ident
@@ -102,7 +132,7 @@ const ABSOLUTE_PATH_REGEX = /^([a-zA-Z]:\\|\\\\|\/)/;
 /**
  * @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 {object=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} new source path
  */
 const contextifySourceUrl = (context, source, associatedObjectForCache) => {
@@ -117,7 +147,7 @@ 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
+ * @param {object=} associatedObjectForCache an object to which the cache will be attached
  * @returns {SourceMap} new source map
  */
 const contextifySourceMap = (context, sourceMap, associatedObjectForCache) => {
@@ -127,14 +157,14 @@ const contextifySourceMap = (context, sourceMap, associatedObjectForCache) => {
 	const mapper = !sourceRoot
 		? source => source
 		: sourceRoot.endsWith("/")
-		? source =>
-				source.startsWith("/")
-					? `${sourceRoot.slice(0, -1)}${source}`
-					: `${sourceRoot}${source}`
-		: source =>
-				source.startsWith("/")
-					? `${sourceRoot}${source}`
-					: `${sourceRoot}/${source}`;
+			? source =>
+					source.startsWith("/")
+						? `${sourceRoot.slice(0, -1)}${source}`
+						: `${sourceRoot}${source}`
+			: source =>
+					source.startsWith("/")
+						? `${sourceRoot}${source}`
+						: `${sourceRoot}/${source}`;
 	const newSources = sourceMap.sources.map(source =>
 		contextifySourceUrl(context, mapper(source), associatedObjectForCache)
 	);
@@ -169,11 +199,14 @@ const asBuffer = input => {
 };
 
 class NonErrorEmittedError extends WebpackError {
+	/**
+	 * @param {any} error value which is not an instance of Error
+	 */
 	constructor(error) {
 		super();
 
 		this.name = "NonErrorEmittedError";
-		this.message = "(Emitted value instead of an instance of Error) " + error;
+		this.message = `(Emitted value instead of an instance of Error) ${error}`;
 	}
 }
 
@@ -184,16 +217,35 @@ makeSerializable(
 );
 
 /**
- * @typedef {Object} NormalModuleCompilationHooks
- * @property {SyncHook<[object, NormalModule]>} loader
- * @property {SyncHook<[LoaderItem[], NormalModule, object]>} beforeLoaders
+ * @typedef {object} NormalModuleCompilationHooks
+ * @property {SyncHook<[LoaderContext<any>, NormalModule]>} loader
+ * @property {SyncHook<[LoaderItem[], NormalModule, LoaderContext<any>]>} beforeLoaders
  * @property {SyncHook<[NormalModule]>} beforeParse
  * @property {SyncHook<[NormalModule]>} beforeSnapshot
- * @property {HookMap<AsyncSeriesBailHook<[string, NormalModule], string | Buffer>>} readResourceForScheme
- * @property {HookMap<AsyncSeriesBailHook<[object], string | Buffer>>} readResource
+ * @property {HookMap<FakeHook<AsyncSeriesBailHook<[string, NormalModule], string | Buffer | null>>>} readResourceForScheme
+ * @property {HookMap<AsyncSeriesBailHook<[LoaderContext<any>], string | Buffer | null>>} readResource
  * @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 {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 {string} context context directory for resolving
+ * @property {string=} matchResource path + query of the matched resource (virtual)
+ * @property {Parser} parser the parser used
+ * @property {ParserOptions=} parserOptions the options of the parser used
+ * @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
+ */
+
 /** @type {WeakMap<Compilation, NormalModuleCompilationHooks>} */
 const compilationHooksMap = new WeakMap();
 
@@ -217,20 +269,32 @@ class NormalModule extends Module {
 				beforeSnapshot: new SyncHook(["module"]),
 				// TODO webpack 6 deprecate
 				readResourceForScheme: new HookMap(scheme => {
-					const hook = hooks.readResource.for(scheme);
+					const hook =
+						/** @type {NormalModuleCompilationHooks} */
+						(hooks).readResource.for(scheme);
 					return createFakeHook(
-						/** @type {AsyncSeriesBailHook<[string, NormalModule], string | Buffer>} */ ({
+						/** @type {AsyncSeriesBailHook<[string, NormalModule], string | Buffer | null>} */ ({
 							tap: (options, fn) =>
 								hook.tap(options, loaderContext =>
-									fn(loaderContext.resource, loaderContext._module)
+									fn(
+										loaderContext.resource,
+										/** @type {NormalModule} */ (loaderContext._module)
+									)
 								),
 							tapAsync: (options, fn) =>
 								hook.tapAsync(options, (loaderContext, callback) =>
-									fn(loaderContext.resource, loaderContext._module, callback)
+									fn(
+										loaderContext.resource,
+										/** @type {NormalModule} */ (loaderContext._module),
+										callback
+									)
 								),
 							tapPromise: (options, fn) =>
 								hook.tapPromise(options, loaderContext =>
-									fn(loaderContext.resource, loaderContext._module)
+									fn(
+										loaderContext.resource,
+										/** @type {NormalModule} */ (loaderContext._module)
+									)
 								)
 						})
 					);
@@ -240,28 +304,16 @@ class NormalModule extends Module {
 				),
 				needBuild: new AsyncSeriesBailHook(["module", "context"])
 			};
-			compilationHooksMap.set(compilation, hooks);
+			compilationHooksMap.set(
+				compilation,
+				/** @type {NormalModuleCompilationHooks} */ (hooks)
+			);
 		}
-		return hooks;
+		return /** @type {NormalModuleCompilationHooks} */ (hooks);
 	}
 
 	/**
-	 * @param {Object} options options object
-	 * @param {string=} options.layer an optional layer in which the module is
-	 * @param {string} options.type module type
-	 * @param {string} options.request request string
-	 * @param {string} options.userRequest request intended by user (without loaders from config)
-	 * @param {string} options.rawRequest request without resolving
-	 * @param {LoaderItem[]} options.loaders list of loaders
-	 * @param {string} options.resource path + query of the real resource
-	 * @param {Record<string, any>=} options.resourceResolveData resource resolve data
-	 * @param {string} options.context context directory for resolving
-	 * @param {string | undefined} options.matchResource path + query of the matched resource (virtual)
-	 * @param {Parser} options.parser the parser used
-	 * @param {object} options.parserOptions the options of the parser used
-	 * @param {Generator} options.generator the generator used
-	 * @param {object} options.generatorOptions the options of the generator used
-	 * @param {Object} options.resolveOptions options used for resolving requests from this module
+	 * @param {NormalModuleCreateData} options options object
 	 */
 	constructor({
 		layer,
@@ -291,11 +343,13 @@ class NormalModule extends Module {
 		this.rawRequest = rawRequest;
 		/** @type {boolean} */
 		this.binary = /^(asset|webassembly)\b/.test(type);
-		/** @type {Parser} */
+		/** @type {undefined | Parser} */
 		this.parser = parser;
+		/** @type {undefined | ParserOptions} */
 		this.parserOptions = parserOptions;
-		/** @type {Generator} */
+		/** @type {undefined | Generator} */
 		this.generator = generator;
+		/** @type {undefined | GeneratorOptions} */
 		this.generatorOptions = generatorOptions;
 		/** @type {string} */
 		this.resource = resource;
@@ -310,13 +364,22 @@ class NormalModule extends Module {
 		}
 
 		// Info from Build
-		/** @type {WebpackError=} */
+		/** @type {WebpackError | null} */
 		this.error = null;
-		/** @private @type {Source=} */
+		/**
+		 * @private
+		 * @type {Source | null}
+		 */
 		this._source = null;
-		/** @private @type {Map<string, number> | undefined} **/
+		/**
+		 * @private
+		 * @type {Map<string | undefined, number> | undefined}
+		 */
 		this._sourceSizes = undefined;
-		/** @private @type {Set<string>} */
+		/**
+		 * @private
+		 * @type {undefined | SourceTypes}
+		 */
 		this._sourceTypes = undefined;
 
 		// Cache
@@ -325,6 +388,8 @@ class NormalModule extends Module {
 		this._isEvaluatingSideEffects = false;
 		/** @type {WeakSet<ModuleGraph> | undefined} */
 		this._addedSideEffectsBailout = undefined;
+		/** @type {Map<string, any>} */
+		this._codeGeneratorData = new Map();
 	}
 
 	/**
@@ -332,14 +397,12 @@ class NormalModule extends Module {
 	 */
 	identifier() {
 		if (this.layer === null) {
-			if (this.type === "javascript/auto") {
+			if (this.type === JAVASCRIPT_MODULE_TYPE_AUTO) {
 				return this.request;
-			} else {
-				return `${this.type}|${this.request}`;
 			}
-		} else {
-			return `${this.type}|${this.request}|${this.layer}`;
+			return `${this.type}|${this.request}`;
 		}
+		return `${this.type}|${this.request}|${this.layer}`;
 	}
 
 	/**
@@ -347,7 +410,7 @@ class NormalModule extends Module {
 	 * @returns {string} a user readable identifier of the module
 	 */
 	readableIdentifier(requestShortener) {
-		return requestShortener.shorten(this.userRequest);
+		return /** @type {string} */ (requestShortener.shorten(this.userRequest));
 	}
 
 	/**
@@ -355,11 +418,13 @@ class NormalModule extends Module {
 	 * @returns {string | null} an identifier for library inclusion
 	 */
 	libIdent(options) {
-		return contextify(
+		let ident = contextify(
 			options.context,
 			this.userRequest,
 			options.associatedObjectForCache
 		);
+		if (this.layer) ident = `(${this.layer})/${ident}`;
+		return ident;
 	}
 
 	/**
@@ -368,7 +433,7 @@ class NormalModule extends Module {
 	nameForCondition() {
 		const resource = this.matchResource || this.resource;
 		const idx = resource.indexOf("?");
-		if (idx >= 0) return resource.substr(0, idx);
+		if (idx >= 0) return resource.slice(0, idx);
 		return resource;
 	}
 
@@ -406,7 +471,7 @@ class NormalModule extends Module {
 		// TODO reconsider this for webpack 6
 		if (this.buildInfo) {
 			if (this._sourceTypes === undefined) this.getSourceTypes();
-			for (const type of this._sourceTypes) {
+			for (const type of /** @type {SourceTypes} */ (this._sourceTypes)) {
 				this.size(type);
 			}
 		}
@@ -420,15 +485,22 @@ class NormalModule extends Module {
 	/**
 	 * Module should be unsafe cached. Get data that's needed for that.
 	 * This data will be passed to restoreFromUnsafeCache later.
-	 * @returns {object} cached data
+	 * @returns {UnsafeCacheData} cached data
 	 */
 	getUnsafeCacheData() {
-		const data = super.getUnsafeCacheData();
+		const data =
+			/** @type {NormalModuleUnsafeCacheData} */
+			(super.getUnsafeCacheData());
 		data.parserOptions = this.parserOptions;
 		data.generatorOptions = this.generatorOptions;
 		return data;
 	}
 
+	/**
+	 * restore unsafe cache data
+	 * @param {NormalModuleUnsafeCacheData} unsafeCacheData data from getUnsafeCacheData
+	 * @param {NormalModuleFactory} normalModuleFactory the normal module factory handling the unsafe caching
+	 */
 	restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) {
 		this._restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory);
 	}
@@ -453,9 +525,9 @@ class NormalModule extends Module {
 	/**
 	 * @param {string} context the compilation context
 	 * @param {string} name the asset name
-	 * @param {string} content the content
-	 * @param {string | TODO} sourceMap an optional source map
-	 * @param {Object=} associatedObjectForCache object for caching
+	 * @param {string | Buffer} content the content
+	 * @param {(string | SourceMap)=} sourceMap an optional source map
+	 * @param {object=} associatedObjectForCache object for caching
 	 * @returns {Source} the created source
 	 */
 	createSourceForAsset(
@@ -480,7 +552,11 @@ class NormalModule extends Module {
 				return new SourceMapSource(
 					content,
 					name,
-					contextifySourceMap(context, sourceMap, associatedObjectForCache)
+					contextifySourceMap(
+						context,
+						/** @type {SourceMap} */ (sourceMap),
+						associatedObjectForCache
+					)
 				);
 			}
 		}
@@ -489,12 +565,14 @@ class NormalModule extends Module {
 	}
 
 	/**
+	 * @private
+	 * @template T
 	 * @param {ResolverWithOptions} resolver a resolver
 	 * @param {WebpackOptions} options webpack options
 	 * @param {Compilation} compilation the compilation
 	 * @param {InputFileSystem} fs file system from reading
 	 * @param {NormalModuleCompilationHooks} hooks the hooks
-	 * @returns {NormalModuleLoaderContext} loader context
+	 * @returns {import("../declarations/LoaderContext").NormalModuleLoaderContext<T>} loader context
 	 */
 	_createLoaderContext(resolver, options, compilation, fs, hooks) {
 		const { requestShortener } = compilation.runtimeTemplate;
@@ -503,56 +581,86 @@ class NormalModule extends Module {
 			if (!currentLoader) return "(not in loader scope)";
 			return requestShortener.shorten(currentLoader.loader);
 		};
-		const getResolveContext = () => {
-			return {
-				fileDependencies: {
-					add: d => loaderContext.addDependency(d)
-				},
-				contextDependencies: {
-					add: d => loaderContext.addContextDependency(d)
-				},
-				missingDependencies: {
-					add: d => loaderContext.addMissingDependency(d)
-				}
-			};
-		};
+		/**
+		 * @returns {ResolveContext} resolve context
+		 */
+		const getResolveContext = () => ({
+			fileDependencies: {
+				add: d => /** @type {TODO} */ (loaderContext).addDependency(d)
+			},
+			contextDependencies: {
+				add: d => /** @type {TODO} */ (loaderContext).addContextDependency(d)
+			},
+			missingDependencies: {
+				add: d => /** @type {TODO} */ (loaderContext).addMissingDependency(d)
+			}
+		});
 		const getAbsolutify = memoize(() =>
 			absolutify.bindCache(compilation.compiler.root)
 		);
 		const getAbsolutifyInContext = memoize(() =>
-			absolutify.bindContextCache(this.context, compilation.compiler.root)
+			absolutify.bindContextCache(
+				/** @type {string} */
+				(this.context),
+				compilation.compiler.root
+			)
 		);
 		const getContextify = memoize(() =>
 			contextify.bindCache(compilation.compiler.root)
 		);
 		const getContextifyInContext = memoize(() =>
-			contextify.bindContextCache(this.context, compilation.compiler.root)
+			contextify.bindContextCache(
+				/** @type {string} */
+				(this.context),
+				compilation.compiler.root
+			)
 		);
 		const utils = {
-			absolutify: (context, request) => {
-				return context === this.context
+			/**
+			 * @param {string} context context
+			 * @param {string} request request
+			 * @returns {string} result
+			 */
+			absolutify: (context, request) =>
+				context === this.context
 					? getAbsolutifyInContext()(request)
-					: getAbsolutify()(context, request);
-			},
-			contextify: (context, request) => {
-				return context === this.context
+					: getAbsolutify()(context, request),
+			/**
+			 * @param {string} context context
+			 * @param {string} request request
+			 * @returns {string} result
+			 */
+			contextify: (context, request) =>
+				context === this.context
 					? getContextifyInContext()(request)
-					: getContextify()(context, request);
-			}
+					: getContextify()(context, request),
+			/**
+			 * @param {(string | typeof import("./util/Hash"))=} type type
+			 * @returns {Hash} hash
+			 */
+			createHash: type =>
+				createHash(
+					type ||
+						/** @type {Algorithm} */
+						(compilation.outputOptions.hashFunction)
+				)
 		};
+		/** @type {import("../declarations/LoaderContext").NormalModuleLoaderContext<T>} */
 		const loaderContext = {
 			version: 2,
 			getOptions: schema => {
 				const loader = this.getCurrentLoader(loaderContext);
 
-				let { options } = loader;
+				let { options } = /** @type {LoaderItem} */ (loader);
 
 				if (typeof options === "string") {
-					if (options.substr(0, 1) === "{" && options.substr(-1) === "}") {
+					if (options.startsWith("{") && options.endsWith("}")) {
 						try {
 							options = parseJson(options);
-						} catch (e) {
-							throw new Error(`Cannot parse string options: ${e.message}`);
+						} catch (err) {
+							throw new Error(
+								`Cannot parse string options: ${/** @type {Error} */ (err).message}`
+							);
 						}
 					} else {
 						options = querystring.parse(options, "&", "=", {
@@ -633,43 +741,61 @@ class NormalModule extends Module {
 				};
 			},
 			emitFile: (name, content, sourceMap, assetInfo) => {
-				if (!this.buildInfo.assets) {
-					this.buildInfo.assets = Object.create(null);
-					this.buildInfo.assetsInfo = new Map();
+				const buildInfo = /** @type {BuildInfo} */ (this.buildInfo);
+
+				if (!buildInfo.assets) {
+					buildInfo.assets = Object.create(null);
+					buildInfo.assetsInfo = new Map();
 				}
-				this.buildInfo.assets[name] = this.createSourceForAsset(
-					options.context,
+
+				const assets =
+					/** @type {NonNullable<KnownBuildInfo["assets"]>} */
+					(buildInfo.assets);
+				const assetsInfo =
+					/** @type {NonNullable<KnownBuildInfo["assetsInfo"]>} */
+					(buildInfo.assetsInfo);
+
+				assets[name] = this.createSourceForAsset(
+					/** @type {string} */ (options.context),
 					name,
 					content,
 					sourceMap,
 					compilation.compiler.root
 				);
-				this.buildInfo.assetsInfo.set(name, assetInfo);
+				assetsInfo.set(name, assetInfo);
 			},
 			addBuildDependency: dep => {
-				if (this.buildInfo.buildDependencies === undefined) {
-					this.buildInfo.buildDependencies = new LazySet();
+				const buildInfo = /** @type {BuildInfo} */ (this.buildInfo);
+
+				if (buildInfo.buildDependencies === undefined) {
+					buildInfo.buildDependencies = new LazySet();
 				}
-				this.buildInfo.buildDependencies.add(dep);
+				buildInfo.buildDependencies.add(dep);
 			},
 			utils,
-			rootContext: options.context,
+			rootContext: /** @type {string} */ (options.context),
 			webpack: true,
-			sourceMap: !!this.useSourceMap,
+			sourceMap: Boolean(this.useSourceMap),
 			mode: options.mode || "production",
 			_module: this,
 			_compilation: compilation,
 			_compiler: compilation.compiler,
-			fs: fs
+			fs
 		};
 
 		Object.assign(loaderContext, options.loader);
 
-		hooks.loader.call(loaderContext, this);
+		hooks.loader.call(/** @type {LoaderContext<any>} */ (loaderContext), this);
 
 		return loaderContext;
 	}
 
+	// TODO remove `loaderContext` in webpack@6
+	/**
+	 * @param {TODO} loaderContext loader context
+	 * @param {number} index index
+	 * @returns {LoaderItem | null} loader
+	 */
 	getCurrentLoader(loaderContext, index = loaderContext.loaderIndex) {
 		if (
 			this.loaders &&
@@ -686,8 +812,8 @@ class NormalModule extends Module {
 	/**
 	 * @param {string} context the compilation context
 	 * @param {string | Buffer} content the content
-	 * @param {string | TODO} sourceMap an optional source map
-	 * @param {Object=} associatedObjectForCache object for caching
+	 * @param {(string | SourceMapSource | null)=} sourceMap an optional source map
+	 * @param {object=} associatedObjectForCache object for caching
 	 * @returns {Source} the created source
 	 */
 	createSource(context, content, sourceMap, associatedObjectForCache) {
@@ -707,7 +833,11 @@ class NormalModule extends Module {
 			return new SourceMapSource(
 				content,
 				contextifySourceUrl(context, identifier, associatedObjectForCache),
-				contextifySourceMap(context, sourceMap, associatedObjectForCache)
+				contextifySourceMap(
+					context,
+					/** @type {TODO} */ (sourceMap),
+					associatedObjectForCache
+				)
 			);
 		}
 
@@ -727,7 +857,7 @@ class NormalModule extends Module {
 	 * @param {ResolverWithOptions} resolver the resolver
 	 * @param {InputFileSystem} fs the file system
 	 * @param {NormalModuleCompilationHooks} hooks the hooks
-	 * @param {function(WebpackError=): void} callback callback function
+	 * @param {function((WebpackError | null)=): void} callback callback function
 	 * @returns {void}
 	 */
 	_doBuild(options, compilation, resolver, fs, hooks, callback) {
@@ -739,7 +869,14 @@ class NormalModule extends Module {
 			hooks
 		);
 
-		const processResult = (err, result) => {
+		/** @typedef {[string | Buffer, string | SourceMapSource, Record<string, any>]}  Result */
+
+		/**
+		 * @param {Error | null} err err
+		 * @param {(Result | null)=} _result result
+		 * @returns {void}
+		 */
+		const processResult = (err, _result) => {
 			if (err) {
 				if (!(err instanceof Error)) {
 					err = new NonErrorEmittedError(err);
@@ -755,6 +892,7 @@ class NormalModule extends Module {
 				return callback(error);
 			}
 
+			const result = /** @type {Result} */ (_result);
 			const source = result[0];
 			const sourceMap = result.length >= 1 ? result[1] : null;
 			const extraInfo = result.length >= 2 ? result[2] : null;
@@ -766,7 +904,7 @@ class NormalModule extends Module {
 						currentLoader
 							? compilation.runtimeTemplate.requestShortener.shorten(
 									currentLoader.loader
-							  )
+								)
 							: "unknown"
 					}) didn't return a Buffer or String`
 				);
@@ -774,9 +912,14 @@ class NormalModule extends Module {
 				return callback(error);
 			}
 
+			const isBinaryModule =
+				this.generatorOptions && this.generatorOptions.binary !== undefined
+					? this.generatorOptions.binary
+					: this.binary;
+
 			this._source = this.createSource(
-				options.context,
-				this.binary ? asBuffer(source) : asString(source),
+				/** @type {string} */ (options.context),
+				isBinaryModule ? asBuffer(source) : asString(source),
 				sourceMap,
 				compilation.compiler.root
 			);
@@ -790,19 +933,29 @@ class NormalModule extends Module {
 			return callback();
 		};
 
-		this.buildInfo.fileDependencies = new LazySet();
-		this.buildInfo.contextDependencies = new LazySet();
-		this.buildInfo.missingDependencies = new LazySet();
-		if (this.loaders.length > 0) {
-			this.buildInfo.buildDependencies = new LazySet();
-		}
-		this.buildInfo.cacheable = true;
+		const buildInfo = /** @type {BuildInfo} */ (this.buildInfo);
+
+		buildInfo.fileDependencies = new LazySet();
+		buildInfo.contextDependencies = new LazySet();
+		buildInfo.missingDependencies = new LazySet();
+		buildInfo.cacheable = true;
+
 		try {
-			hooks.beforeLoaders.call(this.loaders, this, loaderContext);
+			hooks.beforeLoaders.call(
+				this.loaders,
+				this,
+				/** @type {LoaderContext<any>} */ (loaderContext)
+			);
 		} catch (err) {
 			processResult(err);
 			return;
 		}
+
+		if (this.loaders.length > 0) {
+			/** @type {BuildInfo} */
+			(this.buildInfo).buildDependencies = new LazySet();
+		}
+
 		runLoaders(
 			{
 				resource: this.resource,
@@ -816,7 +969,13 @@ class NormalModule extends Module {
 						.callAsync(loaderContext, (err, result) => {
 							if (err) return callback(err);
 							if (typeof result !== "string" && !result) {
-								return callback(new UnhandledSchemeError(scheme, resource));
+								return callback(
+									new UnhandledSchemeError(
+										/** @type {string} */
+										(scheme),
+										resource
+									)
+								);
 							}
 							return callback(null, result);
 						});
@@ -827,23 +986,43 @@ class NormalModule extends Module {
 				loaderContext._compilation =
 					loaderContext._compiler =
 					loaderContext._module =
+					// eslint-disable-next-line no-warning-comments
+					// @ts-ignore
 					loaderContext.fs =
 						undefined;
 
 				if (!result) {
-					this.buildInfo.cacheable = false;
+					/** @type {BuildInfo} */
+					(this.buildInfo).cacheable = false;
 					return processResult(
 						err || new Error("No result from loader-runner processing"),
 						null
 					);
 				}
-				this.buildInfo.fileDependencies.addAll(result.fileDependencies);
-				this.buildInfo.contextDependencies.addAll(result.contextDependencies);
-				this.buildInfo.missingDependencies.addAll(result.missingDependencies);
+
+				const buildInfo = /** @type {BuildInfo} */ (this.buildInfo);
+
+				const fileDependencies =
+					/** @type {NonNullable<KnownBuildInfo["fileDependencies"]>} */
+					(buildInfo.fileDependencies);
+				const contextDependencies =
+					/** @type {NonNullable<KnownBuildInfo["contextDependencies"]>} */
+					(buildInfo.contextDependencies);
+				const missingDependencies =
+					/** @type {NonNullable<KnownBuildInfo["missingDependencies"]>} */
+					(buildInfo.missingDependencies);
+
+				fileDependencies.addAll(result.fileDependencies);
+				contextDependencies.addAll(result.contextDependencies);
+				missingDependencies.addAll(result.missingDependencies);
 				for (const loader of this.loaders) {
-					this.buildInfo.buildDependencies.add(loader.loader);
+					const buildDependencies =
+						/** @type {NonNullable<KnownBuildInfo["buildDependencies"]>} */
+						(buildInfo.buildDependencies);
+
+					buildDependencies.add(loader.loader);
 				}
-				this.buildInfo.cacheable = this.buildInfo.cacheable && result.cacheable;
+				buildInfo.cacheable = buildInfo.cacheable && result.cacheable;
 				processResult(err, result.result);
 			}
 		);
@@ -860,6 +1039,11 @@ class NormalModule extends Module {
 		this.addError(error);
 	}
 
+	/**
+	 * @param {TODO} rule rule
+	 * @param {string} content content
+	 * @returns {boolean} result
+	 */
 	applyNoParseRule(rule, content) {
 		// must start with "rule" if rule is a string
 		if (typeof rule === "string") {
@@ -873,9 +1057,11 @@ class NormalModule extends Module {
 		return rule.test(content);
 	}
 
-	// check if module should not be parsed
-	// returns "true" if the module should !not! be parsed
-	// returns "false" if the module !must! be parsed
+	/**
+	 * @param {TODO} 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
+	 */
 	shouldPreventParsing(noParseRule, request) {
 		// if no noParseRule exists, return false
 		// the module !must! be parsed.
@@ -901,15 +1087,23 @@ class NormalModule extends Module {
 		return false;
 	}
 
+	/**
+	 * @param {Compilation} compilation compilation
+	 * @private
+	 */
 	_initBuildHash(compilation) {
-		const hash = createHash(compilation.outputOptions.hashFunction);
+		const hash = createHash(
+			/** @type {Algorithm} */
+			(compilation.outputOptions.hashFunction)
+		);
 		if (this._source) {
 			hash.update("source");
 			this._source.updateHash(hash);
 		}
 		hash.update("meta");
 		hash.update(JSON.stringify(this.buildMeta));
-		this.buildInfo.hash = /** @type {string} */ (hash.digest("hex"));
+		/** @type {BuildInfo} */
+		(this.buildInfo).hash = /** @type {string} */ (hash.digest("hex"));
 	}
 
 	/**
@@ -955,10 +1149,18 @@ class NormalModule extends Module {
 				return callback();
 			}
 
+			/**
+			 * @param {Error} e error
+			 * @returns {void}
+			 */
 			const handleParseError = e => {
-				const source = this._source.source();
+				const source = /** @type {Source} */ (this._source).source();
 				const loaders = this.loaders.map(item =>
-					contextify(options.context, item.loader, compilation.compiler.root)
+					contextify(
+						/** @type {string} */ (options.context),
+						item.loader,
+						compilation.compiler.root
+					)
 				);
 				const error = new ModuleParseError(source, e, loaders, this.type);
 				this.markModuleAsErrored(error);
@@ -966,7 +1168,7 @@ class NormalModule extends Module {
 				return callback();
 			};
 
-			const handleParseResult = result => {
+			const handleParseResult = () => {
 				this.dependencies.sort(
 					concatComparators(
 						compareSelect(a => a.loc, compareLocations),
@@ -974,7 +1176,9 @@ class NormalModule extends Module {
 					)
 				);
 				this._initBuildHash(compilation);
-				this._lastSuccessfulBuildMeta = this.buildMeta;
+				this._lastSuccessfulBuildMeta =
+					/** @type {BuildMeta} */
+					(this.buildMeta);
 				return handleBuildDone();
 			};
 
@@ -982,17 +1186,22 @@ class NormalModule extends Module {
 				try {
 					hooks.beforeSnapshot.call(this);
 				} catch (err) {
-					this.markModuleAsErrored(err);
+					this.markModuleAsErrored(/** @type {WebpackError} */ (err));
 					return callback();
 				}
 
 				const snapshotOptions = compilation.options.snapshot.module;
-				if (!this.buildInfo.cacheable || !snapshotOptions) {
+				const { cacheable } = /** @type {BuildInfo} */ (this.buildInfo);
+				if (!cacheable || !snapshotOptions) {
 					return callback();
 				}
 				// add warning for all non-absolute paths in fileDependencies, etc
 				// This makes it easier to find problems with watching and/or caching
-				let nonAbsoluteDependencies = undefined;
+				/** @type {undefined | Set<string>} */
+				let nonAbsoluteDependencies;
+				/**
+				 * @param {LazySet<string>} deps deps
+				 */
 				const checkDependencies = deps => {
 					for (const dep of deps) {
 						if (!ABSOLUTE_PATH_REGEX.test(dep)) {
@@ -1004,24 +1213,39 @@ class NormalModule extends Module {
 								const depWithoutGlob = dep.replace(/[\\/]?\*.*$/, "");
 								const absolute = join(
 									compilation.fileSystemInfo.fs,
-									this.context,
+									/** @type {string} */
+									(this.context),
 									depWithoutGlob
 								);
 								if (absolute !== dep && ABSOLUTE_PATH_REGEX.test(absolute)) {
 									(depWithoutGlob !== dep
-										? this.buildInfo.contextDependencies
+										? /** @type {NonNullable<KnownBuildInfo["contextDependencies"]>} */
+											(
+												/** @type {BuildInfo} */ (this.buildInfo)
+													.contextDependencies
+											)
 										: deps
 									).add(absolute);
 								}
-							} catch (e) {
+							} catch (_err) {
 								// ignore
 							}
 						}
 					}
 				};
-				checkDependencies(this.buildInfo.fileDependencies);
-				checkDependencies(this.buildInfo.missingDependencies);
-				checkDependencies(this.buildInfo.contextDependencies);
+				const buildInfo = /** @type {BuildInfo} */ (this.buildInfo);
+				const fileDependencies =
+					/** @type {NonNullable<KnownBuildInfo["fileDependencies"]>} */
+					(buildInfo.fileDependencies);
+				const contextDependencies =
+					/** @type {NonNullable<KnownBuildInfo["contextDependencies"]>} */
+					(buildInfo.contextDependencies);
+				const missingDependencies =
+					/** @type {NonNullable<KnownBuildInfo["missingDependencies"]>} */
+					(buildInfo.missingDependencies);
+				checkDependencies(fileDependencies);
+				checkDependencies(missingDependencies);
+				checkDependencies(contextDependencies);
 				if (nonAbsoluteDependencies !== undefined) {
 					const InvalidDependenciesModuleWarning =
 						getInvalidDependenciesModuleWarning();
@@ -1032,19 +1256,19 @@ class NormalModule extends Module {
 				// convert file/context/missingDependencies into filesystem snapshot
 				compilation.fileSystemInfo.createSnapshot(
 					startTime,
-					this.buildInfo.fileDependencies,
-					this.buildInfo.contextDependencies,
-					this.buildInfo.missingDependencies,
+					fileDependencies,
+					contextDependencies,
+					missingDependencies,
 					snapshotOptions,
 					(err, snapshot) => {
 						if (err) {
 							this.markModuleAsErrored(err);
 							return;
 						}
-						this.buildInfo.fileDependencies = undefined;
-						this.buildInfo.contextDependencies = undefined;
-						this.buildInfo.missingDependencies = undefined;
-						this.buildInfo.snapshot = snapshot;
+						buildInfo.fileDependencies = undefined;
+						buildInfo.contextDependencies = undefined;
+						buildInfo.missingDependencies = undefined;
+						buildInfo.snapshot = snapshot;
 						return callback();
 					}
 				);
@@ -1053,7 +1277,7 @@ class NormalModule extends Module {
 			try {
 				hooks.beforeParse.call(this);
 			} catch (err) {
-				this.markModuleAsErrored(err);
+				this.markModuleAsErrored(/** @type {WebpackError} */ (err));
 				this._initBuildHash(compilation);
 				return callback();
 			}
@@ -1063,26 +1287,27 @@ class NormalModule extends Module {
 			const noParseRule = options.module && options.module.noParse;
 			if (this.shouldPreventParsing(noParseRule, this.request)) {
 				// We assume that we need module and exports
-				this.buildInfo.parsed = false;
+				/** @type {BuildInfo} */
+				(this.buildInfo).parsed = false;
 				this._initBuildHash(compilation);
 				return handleBuildDone();
 			}
 
-			let result;
 			try {
-				const source = this._source.source();
-				result = this.parser.parse(this._ast || source, {
+				const source = /** @type {Source} */ (this._source).source();
+				/** @type {Parser} */
+				(this.parser).parse(this._ast || source, {
 					source,
 					current: this,
 					module: this,
-					compilation: compilation,
-					options: options
+					compilation,
+					options
 				});
-			} catch (e) {
-				handleParseError(e);
+			} catch (parseErr) {
+				handleParseError(/** @type {Error} */ (parseErr));
 				return;
 			}
-			handleParseResult(result);
+			handleParseResult();
 		});
 	}
 
@@ -1091,7 +1316,9 @@ class NormalModule extends Module {
 	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
 	 */
 	getConcatenationBailoutReason(context) {
-		return this.generator.getConcatenationBailoutReason(this, context);
+		return /** @type {Generator} */ (
+			this.generator
+		).getConcatenationBailoutReason(this, context);
 	}
 
 	/**
@@ -1137,17 +1364,18 @@ class NormalModule extends Module {
 			// When caching is implemented here, make sure to not cache when
 			// at least one circular connection was in the loop above
 			return current;
-		} else {
-			return true;
 		}
+		return true;
 	}
 
 	/**
-	 * @returns {Set<string>} types available (do not mutate)
+	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
 		if (this._sourceTypes === undefined) {
-			this._sourceTypes = this.generator.getTypes(this);
+			this._sourceTypes = /** @type {Generator} */ (this.generator).getTypes(
+				this
+			);
 		}
 		return this._sourceTypes;
 	}
@@ -1162,31 +1390,31 @@ class NormalModule extends Module {
 		moduleGraph,
 		chunkGraph,
 		runtime,
-		concatenationScope
+		concatenationScope,
+		codeGenerationResults,
+		sourceTypes
 	}) {
 		/** @type {Set<string>} */
 		const runtimeRequirements = new Set();
 
-		if (!this.buildInfo.parsed) {
+		const { parsed } = /** @type {BuildInfo} */ (this.buildInfo);
+
+		if (!parsed) {
 			runtimeRequirements.add(RuntimeGlobals.module);
 			runtimeRequirements.add(RuntimeGlobals.exports);
 			runtimeRequirements.add(RuntimeGlobals.thisAsExports);
 		}
 
-		/** @type {Map<string, any>} */
-		let data;
-		const getData = () => {
-			if (data === undefined) data = new Map();
-			return data;
-		};
+		/** @type {function(): Map<string, any>} */
+		const getData = () => this._codeGeneratorData;
 
 		const sources = new Map();
-		for (const type of this.generator.getTypes(this)) {
+		for (const type of sourceTypes || chunkGraph.getModuleSourceTypes(this)) {
 			const source = this.error
 				? new RawSource(
-						"throw new Error(" + JSON.stringify(this.error.message) + ");"
-				  )
-				: this.generator.generate(this, {
+						`throw new Error(${JSON.stringify(this.error.message)});`
+					)
+				: /** @type {Generator} */ (this.generator).generate(this, {
 						dependencyTemplates,
 						runtimeTemplate,
 						moduleGraph,
@@ -1194,9 +1422,10 @@ class NormalModule extends Module {
 						runtimeRequirements,
 						runtime,
 						concatenationScope,
+						codeGenerationResults,
 						getData,
 						type
-				  });
+					});
 
 			if (source) {
 				sources.set(type, new CachedSource(source));
@@ -1207,7 +1436,7 @@ class NormalModule extends Module {
 		const resultEntry = {
 			sources,
 			runtimeRequirements,
-			data
+			data: this._codeGeneratorData
 		};
 		return resultEntry;
 	}
@@ -1228,7 +1457,7 @@ class NormalModule extends Module {
 
 	/**
 	 * @param {NeedBuildContext} context context info
-	 * @param {function(WebpackError=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
 	 * @returns {void}
 	 */
 	needBuild(context, callback) {
@@ -1239,15 +1468,16 @@ class NormalModule extends Module {
 		// always try to build in case of an error
 		if (this.error) return callback(null, true);
 
+		const { cacheable, snapshot, valueDependencies } =
+			/** @type {BuildInfo} */ (this.buildInfo);
+
 		// always build when module is not cacheable
-		if (!this.buildInfo.cacheable) return callback(null, true);
+		if (!cacheable) return callback(null, true);
 
 		// build when there is no snapshot to check
-		if (!this.buildInfo.snapshot) return callback(null, true);
+		if (!snapshot) return callback(null, true);
 
 		// build when valueDependencies have changed
-		/** @type {Map<string, string | Set<string>>} */
-		const valueDependencies = this.buildInfo.valueDependencies;
 		if (valueDependencies) {
 			if (!valueCacheVersions) return callback(null, true);
 			for (const [key, value] of valueDependencies) {
@@ -1266,7 +1496,7 @@ class NormalModule extends Module {
 		}
 
 		// check snapshot for validity
-		fileSystemInfo.checkSnapshotValid(this.buildInfo.snapshot, (err, valid) => {
+		fileSystemInfo.checkSnapshotValid(snapshot, (err, valid) => {
 			if (err) return callback(err);
 			if (!valid) return callback(null, true);
 			const hooks = NormalModule.getCompilationHooks(compilation);
@@ -1279,7 +1509,7 @@ class NormalModule extends Module {
 						)
 					);
 				}
-				callback(null, !!needBuild);
+				callback(null, Boolean(needBuild));
 			});
 		});
 	}
@@ -1294,7 +1524,10 @@ class NormalModule extends Module {
 		if (cachedSize !== undefined) {
 			return cachedSize;
 		}
-		const size = Math.max(1, this.generator.getSize(this, type));
+		const size = Math.max(
+			1,
+			/** @type {Generator} */ (this.generator).getSize(this, type)
+		);
 		if (this._sourceSizes === undefined) {
 			this._sourceSizes = new Map();
 		}
@@ -1314,7 +1547,8 @@ class NormalModule extends Module {
 		missingDependencies,
 		buildDependencies
 	) {
-		const { snapshot, buildDependencies: buildDeps } = this.buildInfo;
+		const { snapshot, buildDependencies: buildDeps } =
+			/** @type {BuildInfo} */ (this.buildInfo);
 		if (snapshot) {
 			fileDependencies.addAll(snapshot.getFileIterable());
 			contextDependencies.addAll(snapshot.getContextIterable());
@@ -1324,7 +1558,7 @@ class NormalModule extends Module {
 				fileDependencies: fileDeps,
 				contextDependencies: contextDeps,
 				missingDependencies: missingDeps
-			} = this.buildInfo;
+			} = /** @type {BuildInfo} */ (this.buildInfo);
 			if (fileDeps !== undefined) fileDependencies.addAll(fileDeps);
 			if (contextDeps !== undefined) contextDependencies.addAll(contextDeps);
 			if (missingDeps !== undefined) missingDependencies.addAll(missingDeps);
@@ -1340,14 +1574,18 @@ class NormalModule extends Module {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		hash.update(this.buildInfo.hash);
-		this.generator.updateHash(hash, {
+		hash.update(/** @type {BuildInfo} */ (this.buildInfo).hash);
+		/** @type {Generator} */
+		(this.generator).updateHash(hash, {
 			module: this,
 			...context
 		});
 		super.updateHash(hash, context);
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 		// deserialize
@@ -1355,6 +1593,7 @@ class NormalModule extends Module {
 		write(this.error);
 		write(this._lastSuccessfulBuildMeta);
 		write(this._forceBuild);
+		write(this._codeGeneratorData);
 		super.serialize(context);
 	}
 
@@ -1381,12 +1620,16 @@ class NormalModule extends Module {
 		return obj;
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 		this._source = read();
 		this.error = read();
 		this._lastSuccessfulBuildMeta = read();
 		this._forceBuild = read();
+		this._codeGeneratorData = read();
 		super.deserialize(context);
 	}
 }