webpack 5.98.0 → 5.99.0

package/lib/NormalModule.js

@@ -8,7 +8,12 @@
 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 {
+	HookMap,
+	SyncHook,
+	SyncWaterfallHook,
+	AsyncSeriesBailHook
+} = require("tapable");
 const {
 	CachedSource,
 	OriginalSource,
@@ -57,6 +62,7 @@ const memoize = require("./util/memoize");
 /** @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").BuildMeta} BuildMeta */
 /** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
@@ -65,6 +71,8 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./Module").KnownBuildInfo} KnownBuildInfo */
 /** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
 /** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("./Module").NeedBuildCallback} NeedBuildCallback */
+/** @typedef {import("./Module").BuildCallback} BuildCallback */
 /** @typedef {import("./Generator").SourceTypes} SourceTypes */
 /** @typedef {import("./Module").UnsafeCacheData} UnsafeCacheData */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
@@ -73,6 +81,7 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
 /** @typedef {import("./NormalModuleFactory").ResourceDataWithData} ResourceDataWithData */
 /** @typedef {import("./Parser")} Parser */
+/** @typedef {import("./Parser").PreparsedAst} PreparsedAst */
 /** @typedef {import("./RequestShortener")} RequestShortener */
 /** @typedef {import("./ResolverFactory").ResolveContext} ResolveContext */
 /** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
@@ -84,15 +93,14 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 /** @typedef {import("./util/createHash").Algorithm} Algorithm */
+/** @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
@@ -126,7 +134,7 @@ const ABSOLUTE_PATH_REGEX = /^([a-zA-Z]:\\|\\\\|\/)/;
 /**
  * @typedef {object} LoaderItem
  * @property {string} loader
- * @property {any} options
+ * @property {string | null | undefined | Record<string, EXPECTED_ANY>} options
  * @property {string?} ident
  * @property {string?} type
  */
@@ -134,7 +142,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 {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} new source path
  */
 const contextifySourceUrl = (context, source, associatedObjectForCache) => {
@@ -149,13 +157,13 @@ 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 {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached
  * @returns {SourceMap} new source map
  */
 const contextifySourceMap = (context, sourceMap, associatedObjectForCache) => {
 	if (!Array.isArray(sourceMap.sources)) return sourceMap;
 	const { sourceRoot } = sourceMap;
-	/** @type {function(string): string} */
+	/** @type {(source: string) => string} */
 	const mapper = !sourceRoot
 		? source => source
 		: sourceRoot.endsWith("/")
@@ -202,7 +210,7 @@ const asBuffer = 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,14 +226,17 @@ makeSerializable(
 	"NonErrorEmittedError"
 );
 
+/** @typedef {[string | Buffer, string | SourceMapSource, PreparsedAst]}  Result */
+
 /**
  * @typedef {object} NormalModuleCompilationHooks
- * @property {SyncHook<[LoaderContext<any>, NormalModule]>} loader
- * @property {SyncHook<[LoaderItem[], NormalModule, LoaderContext<any>]>} beforeLoaders
+ * @property {SyncHook<[LoaderContext<EXPECTED_ANY>, NormalModule]>} loader
+ * @property {SyncHook<[LoaderItem[], NormalModule, LoaderContext<EXPECTED_ANY>]>} 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<[LoaderContext<EXPECTED_ANY>], string | Buffer | null>>} readResource
+ * @property {SyncWaterfallHook<[Result, NormalModule]>} processResult
  * @property {AsyncSeriesBailHook<[NormalModule, NeedBuildContext], boolean>} needBuild
  */
 
@@ -238,7 +249,7 @@ makeSerializable(
  * @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 {TODO=} 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
@@ -251,6 +262,8 @@ makeSerializable(
 /** @type {WeakMap<Compilation, NormalModuleCompilationHooks>} */
 const compilationHooksMap = new WeakMap();
 
+/** @typedef {Map<string, EXPECTED_ANY>} CodeGeneratorData */
+
 class NormalModule extends Module {
 	/**
 	 * @param {Compilation} compilation the compilation
@@ -304,6 +317,7 @@ class NormalModule extends Module {
 				readResource: new HookMap(
 					() => new AsyncSeriesBailHook(["loaderContext"])
 				),
+				processResult: new SyncWaterfallHook(["result", "module"]),
 				needBuild: new AsyncSeriesBailHook(["module", "context"])
 			};
 			compilationHooksMap.set(
@@ -390,7 +404,7 @@ class NormalModule extends Module {
 		this._isEvaluatingSideEffects = false;
 		/** @type {WeakSet<ModuleGraph> | undefined} */
 		this._addedSideEffectsBailout = undefined;
-		/** @type {Map<string, any>} */
+		/** @type {CodeGeneratorData} */
 		this._codeGeneratorData = new Map();
 	}
 
@@ -490,9 +504,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 +512,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 +521,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) {
@@ -529,7 +541,7 @@ class NormalModule extends Module {
 	 * @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 {AssociatedObjectForCache=} associatedObjectForCache object for caching
 	 * @returns {Source} the created source
 	 */
 	createSourceForAsset(
@@ -650,6 +662,10 @@ class NormalModule extends Module {
 		/** @type {import("../declarations/LoaderContext").NormalModuleLoaderContext<T>} */
 		const loaderContext = {
 			version: 2,
+			/**
+			 * @param {import("../declarations/LoaderContext").Schema} [schema] schema
+			 * @returns {T} options
+			 */
 			getOptions: schema => {
 				const loader = this.getCurrentLoader(loaderContext);
 
@@ -682,13 +698,13 @@ 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 => {
 				if (!(warning instanceof Error)) {
@@ -723,24 +739,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);
@@ -791,7 +815,11 @@ class NormalModule extends Module {
 
 		Object.assign(loaderContext, options.loader);
 
-		hooks.loader.call(/** @type {LoaderContext<any>} */ (loaderContext), this);
+		hooks.loader.call(
+			/** @type {LoaderContext<EXPECTED_ANY>} */
+			(loaderContext),
+			this
+		);
 
 		return loaderContext;
 	}
@@ -819,7 +847,7 @@ 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 {AssociatedObjectForCache=} associatedObjectForCache object for caching
 	 * @returns {Source} the created source
 	 */
 	createSource(context, content, sourceMap, associatedObjectForCache) {
@@ -863,7 +891,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,8 +903,6 @@ class NormalModule extends Module {
 			hooks
 		);
 
-		/** @typedef {[string | Buffer, string | SourceMapSource, Record<string, any>]}  Result */
-
 		/**
 		 * @param {Error | null} err err
 		 * @param {(Result | null)=} _result result
@@ -897,8 +923,10 @@ 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;
@@ -950,7 +978,8 @@ class NormalModule extends Module {
 			hooks.beforeLoaders.call(
 				this.loaders,
 				this,
-				/** @type {LoaderContext<any>} */ (loaderContext)
+				/** @type {LoaderContext<EXPECTED_ANY>} */
+				(loaderContext)
 			);
 		} catch (err) {
 			processResult(/** @type {Error} */ (err));
@@ -997,10 +1026,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} */
@@ -1122,7 +1150,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) {
@@ -1232,8 +1260,8 @@ class NormalModule extends Module {
 									(depWithoutGlob !== dep
 										? /** @type {NonNullable<KnownBuildInfo["contextDependencies"]>} */
 											(
-												/** @type {BuildInfo} */ (this.buildInfo)
-													.contextDependencies
+												/** @type {BuildInfo} */
+												(this.buildInfo).contextDependencies
 											)
 										: deps
 									).add(absolute);
@@ -1416,16 +1444,35 @@ class NormalModule extends Module {
 			runtimeRequirements.add(RuntimeGlobals.thisAsExports);
 		}
 
-		/** @type {function(): Map<string, any>} */
+		/**
+		 * @type {() => CodeGeneratorData}
+		 */
 		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 +1515,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) {

package/lib/NormalModuleFactory.js

@@ -37,6 +37,7 @@ const {
 /** @typedef {import("../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
 /** @typedef {import("../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
 /** @typedef {import("./Generator")} Generator */
+/** @typedef {import("./ModuleFactory").ModuleFactoryCallback} ModuleFactoryCallback */
 /** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
 /** @typedef {import("./ModuleFactory").ModuleFactoryCreateDataContextInfo} ModuleFactoryCreateDataContextInfo */
 /** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
@@ -50,7 +51,10 @@ const {
 /** @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 */
 /** @typedef {Partial<NormalModuleCreateData & { settings: ModuleSettings }>} CreateData */
@@ -61,7 +65,7 @@ const {
  * @property {ModuleFactoryCreateData["resolveOptions"]} resolveOptions
  * @property {string} context
  * @property {string} request
- * @property {Record<string, any> | undefined} assertions
+ * @property {ImportAttributes | undefined} assertions
  * @property {ModuleDependency[]} dependencies
  * @property {string} dependencyType
  * @property {CreateData} createData
@@ -81,7 +85,7 @@ const {
  * @property {string=} context
  */
 
-/** @typedef {ResourceData & { data: Record<string, any> }} ResourceDataWithData */
+/** @typedef {ResourceData & { data: Record<string, EXPECTED_ANY> }} ResourceDataWithData */
 
 /**
  * @typedef {object} ParsedLoaderRequest
@@ -186,20 +190,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. ` +
@@ -224,14 +221,16 @@ const ruleSetCompiler = new RuleSetCompiler([
 	new BasicMatcherRulePlugin("issuerLayer"),
 	new ObjectMatcherRulePlugin("assert", "assertions", value => {
 		if (value) {
-			return /** @type {any} */ (value)._isLegacyAssert !== undefined;
+			return (
+				/** @type {ImportAttributes} */ (value)._isLegacyAssert !== undefined
+			);
 		}
 
 		return false;
 	}),
 	new ObjectMatcherRulePlugin("with", "assertions", value => {
 		if (value) {
-			return !(/** @type {any} */ (value)._isLegacyAssert);
+			return !(/** @type {ImportAttributes} */ (value)._isLegacyAssert);
 		}
 		return false;
 	}),
@@ -252,7 +251,7 @@ 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 {AssociatedObjectForCache} param.associatedObjectForCache an object to which the cache will be attached
 	 * @param {boolean=} param.layers enable layers
 	 */
 	constructor({
@@ -281,9 +280,9 @@ 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>>} */
 			createParser: new HookMap(() => new SyncBailHook(["parserOptions"])),
@@ -305,19 +304,19 @@ 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();
@@ -459,9 +458,10 @@ class NormalModuleFactory extends ModuleFactory {
 								matchResource = join(this.fs, context, matchResource);
 							}
 						}
+
 						matchResourceData = {
 							resource: matchResource,
-							...cacheParseResource(matchResource)
+							.../** @type {TODO} */ (cacheParseResource(matchResource))
 						};
 						requestWithoutMatchResource = request.slice(
 							matchResourceMatch[0].length
@@ -546,7 +546,11 @@ class NormalModuleFactory extends ModuleFactory {
 
 					if (!resourceData) {
 						// ignored
-						return callback(null, dependencies[0].createIgnoredModule(context));
+						return callback(
+							null,
+							/** @type {TODO} */
+							(dependencies[0].createIgnoredModule(context))
+						);
 					}
 
 					const userRequest =
@@ -624,12 +628,13 @@ class NormalModuleFactory extends ModuleFactory {
 								] === "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);
+								/** @type {TODO} */
+								(settings)[type] = cachedCleverMerge(settings[type], r.value);
 							} else {
-								settings[r.type] = r.value;
+								const type = /** @type {keyof ModuleSettings} */ (r.type);
+								/** @type {TODO} */
+								(settings)[type] = r.value;
 							}
 						}
 					}
@@ -756,7 +761,7 @@ class NormalModuleFactory extends ModuleFactory {
 						resourceData = {
 							resource: unresolvedResource,
 							data: {},
-							...cacheParseResource(unresolvedResource)
+							.../** @type {TODO} */ (cacheParseResource(unresolvedResource))
 						};
 						continueCallback();
 					}
@@ -790,7 +795,8 @@ class NormalModuleFactory extends ModuleFactory {
 										data:
 											/** @type {ResolveRequest} */
 											(resolvedResourceResolveData),
-										...cacheParseResource(resolvedResource)
+										.../** @type {TODO} */
+										(cacheParseResource(resolvedResource))
 									};
 								}
 								continueCallback();
@@ -852,7 +858,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) {
@@ -862,12 +868,11 @@ class NormalModuleFactory extends ModuleFactory {
 		const dependency = dependencies[0];
 		const request = dependency.request;
 		const assertions = dependency.assertions;
+		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,

package/lib/NormalModuleReplacementPlugin.js

@@ -8,15 +8,16 @@
 const { join, dirname } = require("./util/fs");
 
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./NormalModuleFactory").ResolveData} ResolveData */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 
-/** @typedef {function(import("./NormalModuleFactory").ResolveData): void} ModuleReplacer */
+/** @typedef {(resolveData: ResolveData) => void} ModuleReplacer */
 
 class NormalModuleReplacementPlugin {
 	/**
 	 * Create an instance of the plugin
 	 * @param {RegExp} resourceRegExp the resource matcher
-	 * @param {string|ModuleReplacer} newResource the resource replacement
+	 * @param {string | ModuleReplacer} newResource the resource replacement
 	 */
 	constructor(resourceRegExp, newResource) {
 		this.resourceRegExp = resourceRegExp;

package/lib/NullFactory.js

@@ -7,13 +7,13 @@
 
 const ModuleFactory = require("./ModuleFactory");
 
+/** @typedef {import("./ModuleFactory").ModuleFactoryCallback} ModuleFactoryCallback */
 /** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
 
 class NullFactory extends ModuleFactory {
 	/**
 	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function((Error | null)=, ModuleFactoryResult=): void} callback callback
+	 * @param {ModuleFactoryCallback} callback callback
 	 * @returns {void}
 	 */
 	create(data, callback) {

package/lib/Parser.js

@@ -5,10 +5,11 @@
 
 "use strict";
 
+/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
 /** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./NormalModule")} NormalModule */
 
-/** @typedef {Record<string, any>} PreparsedAst */
+/** @typedef {Record<string, EXPECTED_ANY>} PreparsedAst */
 
 /**
  * @typedef {object} ParserStateBase
@@ -16,10 +17,10 @@
  * @property {NormalModule} current
  * @property {NormalModule} module
  * @property {Compilation} compilation
- * @property {{[k: string]: any}} options
+ * @property {WebpackOptions} options
  */
 
-/** @typedef {Record<string, any> & ParserStateBase} ParserState */
+/** @typedef {Record<string, EXPECTED_ANY> & ParserStateBase} ParserState */
 
 class Parser {
 	/* istanbul ignore next */