webpack 5.112.0 → 5.112.2

package/lib/loaders/LoaderRunner.js

@@ -21,25 +21,37 @@ const LOADER_TIMING = Symbol("loader timing");
 
 /** @typedef {string | { loader: string, options?: LoaderItem["options"], ident?: string | null, type?: string | null, fragment?: string }} LoaderItemInput */
 
+/**
+ * What a loader hands on: content (`null` for a resource without a path),
+ * source map and additional data.
+ * @typedef {[(string | Buffer | null)?, (string | RawSourceMap | null)?, AdditionalData?]} LoaderResultArgs
+ */
+
+/**
+ * @template C
+ * @typedef {(loaderContext: C, resource: string, callback: (err: Error | null, ...args: LoaderResultArgs) => void) => void} ProcessResource
+ */
+
 /**
  * @typedef {object} ProcessOptions
- * @property {Buffer | null} resourceBuffer the raw resource buffer
- * @property {(loaderContext: EXPECTED_ANY, resource: string, callback: (err: Error | null, ...args: EXPECTED_ANY[]) => void) => void} processResource read and process the resource
+ * @property {string | Buffer | null | undefined} resourceBuffer the resource as read, a string when a `readResource` tap answered one
+ * @property {ProcessResource<LoaderContext>} processResource read and process the resource
  */
 
 /**
+ * @template C
  * @typedef {object} RunLoaderOptions
  * @property {string=} resource the resource (with query and fragment)
  * @property {LoaderItemInput[]=} loaders the loaders to run
- * @property {EXPECTED_ANY=} context the loader context to augment and pass to loaders
- * @property {ProcessOptions["processResource"]=} processResource custom resource reader/processor
+ * @property {C=} context the loader context to augment and pass to loaders
+ * @property {ProcessResource<C>=} processResource custom resource reader/processor
  * @property {((path: string, callback: (err: Error | null, result?: Buffer) => void) => void)=} readResource custom file reader
  */
 
 /**
  * @typedef {object} RunLoaderResult
- * @property {EXPECTED_ANY=} result the loader pipeline result
- * @property {Buffer | null=} resourceBuffer the raw resource buffer
+ * @property {LoaderResultArgs=} result the loader pipeline result
+ * @property {(string | Buffer | null)=} resourceBuffer the resource as read, a string when a `readResource` tap answered one
  * @property {boolean} cacheable whether the request is cacheable
  * @property {string[]} notCacheableReasons reasons why the request is not cacheable (e.g. paths of loaders that marked it)
  * @property {string[]} fileDependencies file dependencies
@@ -47,11 +59,13 @@ const LOADER_TIMING = Symbol("loader timing");
  * @property {string[]} missingDependencies missing dependencies
  */
 
-/** @typedef {(...args: EXPECTED_ANY[]) => void} LoaderCallback */
+/** @typedef {(err?: Error | null, ...args: LoaderResultArgs) => void} LoaderCallback */
+
+/** @typedef {{ then: (onFulfilled: (content: string | Buffer) => void, onRejected: LoaderCallback) => void }} LoaderThenable */
 
 /**
  * @typedef {object} AdditionalDataKnown
- * @property {PreparsedAst} webpackAST the AST webpack should parse instead of the source
+ * @property {PreparsedAst=} webpackAST the AST webpack should parse instead of the source
  */
 
 /** @typedef {AdditionalDataKnown & Record<string, EXPECTED_ANY>} AdditionalData */
@@ -66,17 +80,25 @@ const LOADER_TIMING = Symbol("loader timing");
  */
 
 /**
+ * What a loader keeps between its pitch and normal phase. Open by default: a
+ * loader stores whatever it likes, and reads it back without narrowing.
+ * @typedef {{ [key: string]: EXPECTED_ANY }} LoaderData
+ */
+
+/**
+ * @template [OptionsType=LoaderOptions]
+ * @template [DataType=LoaderData]
  * @typedef {object} LoaderEntry
  * @property {string} request
  * @property {string} path
  * @property {string} query
  * @property {string} fragment
- * @property {Record<string, EXPECTED_ANY> | string | undefined} options
+ * @property {string | null | undefined | OptionsType} options
  * @property {string} ident
- * @property {LoaderDefinitionFunction<EXPECTED_ANY> | RawLoaderDefinitionFunction<EXPECTED_ANY> | undefined} normal
- * @property {PitchLoaderDefinitionFunction<EXPECTED_ANY> | undefined} pitch
+ * @property {LoaderDefinitionFunction<OptionsType> | RawLoaderDefinitionFunction<OptionsType> | undefined} normal
+ * @property {PitchLoaderDefinitionFunction<OptionsType> | undefined} pitch
  * @property {boolean | undefined} raw
- * @property {Record<string, EXPECTED_ANY> | undefined} data
+ * @property {DataType | undefined} data
  * @property {boolean} pitchExecuted
  * @property {boolean} normalExecuted
  * @property {("commonjs" | "module")=} type
@@ -86,7 +108,8 @@ const LOADER_TIMING = Symbol("loader timing");
  * The members the runner never lets a loader assign. They carry no
  * documentation, so a type literal loses nothing and keeps `readonly`
  * @template OptionsType
- * @typedef {{ readonly currentRequest: string, readonly data: EXPECTED_ANY, readonly previousRequest: string, readonly query: string | OptionsType, readonly remainingRequest: string, readonly request: string }} LoaderRunnerReadonlyContext
+ * @template [DataType=LoaderData]
+ * @typedef {{ readonly currentRequest: string, readonly data: DataType, readonly previousRequest: string, readonly query: string | OptionsType, readonly remainingRequest: string, readonly request: string }} LoaderRunnerReadonlyContext
  */
 
 /**
@@ -134,13 +157,14 @@ const LOADER_TIMING = Symbol("loader timing");
 /**
  * The properties are added by https://github.com/webpack/loader-runner
  * @template OptionsType
- * @typedef {LoaderRunnerMutableContext<OptionsType> & LoaderRunnerReadonlyContext<OptionsType>} LoaderRunnerLoaderContext
+ * @template [DataType=LoaderData]
+ * @typedef {LoaderRunnerMutableContext<OptionsType> & LoaderRunnerReadonlyContext<OptionsType, DataType>} LoaderRunnerLoaderContext
  */
 
 /**
  * @template [OptionsType={}]
  * @template [ContextAdditions={}]
- * @typedef {(this: import("../module/NormalModule").LoaderContext<OptionsType> & ContextAdditions, remainingRequest: string, previousRequest: string, data: Record<string, EXPECTED_ANY>) => string | Buffer | Promise<string | Buffer> | void} PitchLoaderDefinitionFunction
+ * @typedef {(this: import("../module/NormalModule").LoaderContext<OptionsType> & ContextAdditions, remainingRequest: string, previousRequest: string, data: LoaderData) => string | Buffer | Promise<string | Buffer> | void} PitchLoaderDefinitionFunction
  */
 
 /**
@@ -181,9 +205,13 @@ const LOADER_TIMING = Symbol("loader timing");
  * `LoaderRunnerLoaderContext` shape (not re-declared here), with only the fields
  * the runner assigns internally before a loader runs widened to their mutable
  * form (nullable `context`/`callback`/`async`, `LoaderObject` loaders).
- * @typedef {Omit<LoaderRunnerLoaderContext<EXPECTED_ANY>, "context" | "callback" | "async" | "loaders"> & { context: string | null, callback: LoaderCallback | null, async: (() => LoaderCallback | undefined) | null, loaders: LoaderObject[] }} LoaderContext
+ * @typedef {Omit<LoaderRunnerLoaderContext<LoaderOptions>, "context" | "callback" | "async" | "loaders"> & { context: string | null, callback: LoaderCallback | null, async: (() => LoaderCallback | undefined) | null, loaders: LoaderObject[] }} LoaderContext
  */
 
+/** @typedef {NonNullable<Exclude<LoaderItem["options"], string>>} LoaderOptions */
+
+/** @typedef {[string, string, NonNullable<LoaderObject["data"]>]} PitchArgs */
+
 const HASH_ESCAPE_REGEXP = /#/g;
 
 // UTF-8 encoding of the BOM: EF BB BF
@@ -258,19 +286,19 @@ class LoaderObject {
 		this.query = "";
 		/** @type {string} */
 		this.fragment = "";
-		/** @type {string | { [key: string]: EXPECTED_ANY } | null=} */
+		/** @type {LoaderItem["options"]} */
 		this.options = null;
 		/** @type {string | null=} */
 		this.ident = null;
 		/** @type {(string | null)=} */
 		this.type = undefined;
-		/** @type {LoaderDefinitionFunction<EXPECTED_ANY> | RawLoaderDefinitionFunction<EXPECTED_ANY> | null=} */
+		/** @type {LoaderDefinitionFunction<LoaderOptions> | RawLoaderDefinitionFunction<LoaderOptions> | null=} */
 		this.normal = null;
-		/** @type {PitchLoaderDefinitionFunction<EXPECTED_ANY> | null=} */
+		/** @type {PitchLoaderDefinitionFunction<LoaderOptions> | null=} */
 		this.pitch = null;
 		/** @type {boolean | null=} */
 		this.raw = null;
-		/** @type {Record<string, EXPECTED_ANY> | null=} */
+		/** @type {LoaderData | null=} */
 		this.data = null;
 		this.pitchExecuted = false;
 		this.normalExecuted = false;
@@ -340,9 +368,9 @@ const REQUEST_DESCRIPTOR = {
 };
 
 /**
- * @param {LoaderDefinitionFunction<EXPECTED_ANY> | RawLoaderDefinitionFunction<EXPECTED_ANY> | PitchLoaderDefinitionFunction<EXPECTED_ANY>} fn the loader function
+ * @param {NonNullable<LoaderObject["normal"] | LoaderObject["pitch"]>} fn the loader function
  * @param {LoaderContext} context the loader context
- * @param {EXPECTED_ANY[]} args arguments
+ * @param {LoaderResultArgs | PitchArgs} args arguments
  * @param {LoaderCallback} callback callback
  * @returns {void}
  */
@@ -353,7 +381,7 @@ function runSyncOrAsync(fn, context, args, callback) {
 	let reportedError = false;
 
 	/**
-	 * @param {...EXPECTED_ANY} callbackArgs callback args
+	 * @param {Parameters<LoaderCallback>} callbackArgs callback args
 	 * @returns {void}
 	 */
 	function innerCallback(...callbackArgs) {
@@ -387,7 +415,7 @@ function runSyncOrAsync(fn, context, args, callback) {
 
 	// The runner types its context more loosely than a loader's `this`.
 	const loader =
-		/** @type {(this: LoaderContext, ...args: EXPECTED_ANY[]) => EXPECTED_ANY} */ (
+		/** @type {(this: LoaderContext, ...args: LoaderResultArgs | PitchArgs) => ReturnType<LoaderDefinitionFunction>} */ (
 			fn
 		);
 	const timing =
@@ -408,13 +436,13 @@ function runSyncOrAsync(fn, context, args, callback) {
 			if (
 				result &&
 				typeof result === "object" &&
-				typeof result.then === "function"
+				typeof (/** @type {LoaderThenable} */ (result).then) === "function"
 			) {
-				return result.then((/** @type {EXPECTED_ANY} */ r) => {
+				return /** @type {LoaderThenable} */ (result).then((r) => {
 					callback(null, r);
 				}, callback);
 			}
-			return callback(null, result);
+			return callback(null, /** @type {string | Buffer} */ (result));
 		}
 	} catch (err) {
 		if (isError) throw err;
@@ -436,7 +464,7 @@ function runSyncOrAsync(fn, context, args, callback) {
 }
 
 /**
- * @param {EXPECTED_ANY[]} args arguments
+ * @param {LoaderResultArgs} args arguments
  * @param {boolean | null=} raw whether the loader wants a Buffer
  * @param {boolean=} fromLoader whether args came from a loader rather than the resource
  * @returns {void}
@@ -461,8 +489,8 @@ function convertArgs(args, raw, fromLoader) {
 /**
  * @param {ProcessOptions} options process options
  * @param {LoaderContext} loaderContext the loader context
- * @param {EXPECTED_ANY[]} args arguments
- * @param {(err: Error | null, args?: EXPECTED_ANY[]) => void} callback callback
+ * @param {LoaderResultArgs} args arguments
+ * @param {(err: Error | null, args?: LoaderResultArgs) => void} callback callback
  * @param {boolean=} fromLoader whether args came from a loader rather than the resource
  * @returns {void}
  */
@@ -504,7 +532,7 @@ function iterateNormalLoaders(
 /**
  * @param {ProcessOptions} options process options
  * @param {LoaderContext} loaderContext the loader context
- * @param {(err: Error | null, args?: EXPECTED_ANY[]) => void} callback callback
+ * @param {(err: Error | null, args?: LoaderResultArgs) => void} callback callback
  * @returns {void}
  */
 function processResource(options, loaderContext, callback) {
@@ -522,14 +550,19 @@ function processResource(options, loaderContext, callback) {
 
 		options.resourceBuffer = args[0];
 
-		iterateNormalLoaders(options, loaderContext, args, callback);
+		iterateNormalLoaders(
+			options,
+			loaderContext,
+			/** @type {LoaderResultArgs} */ (args),
+			callback
+		);
 	});
 }
 
 /**
  * @param {ProcessOptions} options process options
  * @param {LoaderContext} loaderContext the loader context
- * @param {(err: Error | null, args?: EXPECTED_ANY[]) => void} callback callback
+ * @param {(err: Error | null, args?: LoaderResultArgs) => void} callback callback
  * @returns {void}
  */
 function iteratePitchingLoaders(options, loaderContext, callback) {
@@ -713,7 +746,8 @@ function createLoaderContext(base) {
  * Marks the request as not cacheable with the given reasons instead of
  * attributing the currently running loader (used by the host when the cause
  * lives outside the loader, e.g. in a child compilation of `importModule`).
- * @param {LoaderRunnerLoaderContext<EXPECTED_ANY>} loaderContext loader context
+ * @template OptionsType
+ * @param {LoaderRunnerLoaderContext<OptionsType>} loaderContext loader context
  * @param {string[]} reasons reasons why the request is not cacheable
  * @returns {void}
  */
@@ -815,7 +849,8 @@ const ACCESSORS = {
 };
 
 /**
- * @param {RunLoaderOptions} options run options
+ * @template [C=LoaderContext]
+ * @param {RunLoaderOptions<C>} options run options
  * @param {(err: Error | null, result: RunLoaderResult) => void} callback callback
  * @returns {void}
  */
@@ -826,7 +861,9 @@ module.exports.runLoaders = function runLoaders(options, callback) {
 	// host hook such as `beforeLoaders` can pre-add dependencies or mark the
 	// request non-cacheable before the run; a caller re-running on the same context
 	// should `clearDependencies()` first, to avoid accumulating stale ones.
-	const provided = options.context;
+	const provided =
+		/** @type {{ [LOADER_STATE]?: LoaderState } | undefined} */
+		(options.context);
 	const loaderContext =
 		provided && provided[LOADER_STATE]
 			? /** @type {LoaderContext} */ (provided)
@@ -851,8 +888,9 @@ module.exports.runLoaders = function runLoaders(options, callback) {
 	);
 
 	const processResourceFn =
-		options.processResource ||
-		/** @type {(readResource: NonNullable<RunLoaderOptions["readResource"]>, context: LoaderContext, res: string, cb: (err: Error | null, result?: Buffer) => void) => void} */
+		/** @type {ProcessResource<LoaderContext> | undefined} */
+		(options.processResource) ||
+		/** @type {(readResource: NonNullable<RunLoaderOptions<C>["readResource"]>, context: LoaderContext, res: string, cb: (err: Error | null, result?: Buffer) => void) => void} */
 		(
 			(readResource, context, res, cb) => {
 				context.addDependency(res);

package/lib/loaders/loadLoader.js

@@ -12,18 +12,27 @@ const getLoaderLoadingError = memoize(() =>
 	require("../errors/LoaderLoadingError")
 );
 
-/** @import { LoaderObject } from "./LoaderRunner" */
+/**
+ * @import {
+ * 	LoaderDefinition,
+ * 	LoaderModule,
+ * 	LoaderObject,
+ * 	RawLoaderDefinition
+ * } from "./LoaderRunner"
+ */
+
+/** @typedef {LoaderDefinition | RawLoaderDefinition | LoaderModule} LoadedLoader */
 
 /**
  * Lazily-compiled dynamic `import()`. Built on first use so this file still
  * parses on Node versions without native `import()` (<13.2), then reused.
- * @type {((url: URL) => Promise<EXPECTED_ANY>) | undefined}
+ * @type {((url: URL) => Promise<LoadedLoader>) | undefined}
  */
 let importModule;
 
 /**
  * @param {LoaderObject} loader the loader to load into
- * @param {EXPECTED_ANY} module the loaded module
+ * @param {LoadedLoader} module the loaded module
  * @param {(err?: Error) => void} callback callback
  * @returns {void}
  */
@@ -66,17 +75,14 @@ function loadLoader(loader, callback) {
 				// loadable on Node versions that can't parse it (<13.2).
 				// eslint-disable-next-line no-eval
 				const dynamicImport = eval("(url) => import(url)");
-				importModule = /** @type {(url: URL) => Promise<EXPECTED_ANY>} */ (
+				importModule = /** @type {(url: URL) => Promise<LoadedLoader>} */ (
 					dynamicImport
 				);
 			}
 
-			importModule(pathToFileURL(loader.path)).then(
-				(/** @type {EXPECTED_ANY} */ module) => {
-					handleResult(loader, module, callback);
-				},
-				callback
-			);
+			importModule(pathToFileURL(loader.path)).then((module) => {
+				handleResult(loader, module, callback);
+			}, callback);
 		} catch (err) {
 			callback(/** @type {Error} */ (err));
 		}

package/lib/module/Generator.js

@@ -56,8 +56,9 @@ const { JAVASCRIPT_TYPE } = require("./ModuleSourceTypeConstants");
 
 /**
  * Represents the generator runtime component.
+ * @template {NormalModule} [TModule=NormalModule]
  * @typedef {object} UpdateHashContext
- * @property {NormalModule} module the module
+ * @property {TModule} module the module
  * @property {ChunkGraph} chunkGraph
  * @property {RuntimeSpec} runtime
  * @property {RuntimeTemplate=} runtimeTemplate
@@ -67,6 +68,9 @@ const getModuleParseError = memoize(() =>
 	require("../errors/ModuleParseError")
 );
 
+/**
+ * @template {NormalModule} [TModule=NormalModule] the module class this generator generates
+ */
 class Generator {
 	/**
 	 * Returns generator by type.
@@ -115,7 +119,7 @@ class Generator {
 	/**
 	 * Returns the source types available for this module.
 	 * @abstract
-	 * @param {NormalModule} module fresh module
+	 * @param {TModule} module fresh module
 	 * @returns {SourceTypes} available types (do not mutate)
 	 */
 	getTypes(module) {
@@ -135,7 +139,7 @@ class Generator {
 	/**
 	 * Returns the estimated size for the requested source type.
 	 * @abstract
-	 * @param {NormalModule} module the module
+	 * @param {TModule} module the module
 	 * @param {SourceType=} type source type
 	 * @returns {number} estimate size of the module
 	 */
@@ -149,7 +153,7 @@ class Generator {
 	/**
 	 * Generates generated code for this runtime module.
 	 * @abstract
-	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {TModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
 	 * @returns {Source | null} generated code
 	 */
@@ -164,7 +168,7 @@ class Generator {
 
 	/**
 	 * Returns the reason this module cannot be concatenated, when one exists.
-	 * @param {NormalModule} module module for which the bailout reason should be determined
+	 * @param {TModule} module module for which the bailout reason should be determined
 	 * @param {ConcatenationBailoutReasonContext} context context
 	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
 	 */
@@ -175,7 +179,7 @@ class Generator {
 	/**
 	 * Updates the hash with the data contributed by this instance.
 	 * @param {Hash} hash hash that will be modified
-	 * @param {UpdateHashContext} updateHashContext context for updating hash
+	 * @param {UpdateHashContext<TModule>} updateHashContext context for updating hash
 	 */
 	updateHash(hash, { module, runtime }) {
 		// no nothing
@@ -200,6 +204,10 @@ function generateError(error, module, generateContext) {
 	return generator.generateError(error, module, generateContext);
 }
 
+/**
+ * @template {NormalModule} [TModule=NormalModule] the module class this generator generates
+ * @extends {Generator<TModule>}
+ */
 class ByTypeGenerator extends Generator {
 	/**
 	 * Creates an instance of ByTypeGenerator.
@@ -216,7 +224,7 @@ class ByTypeGenerator extends Generator {
 
 	/**
 	 * Returns the source types available for this module.
-	 * @param {NormalModule} module fresh module
+	 * @param {TModule} module fresh module
 	 * @returns {SourceTypes} available types (do not mutate)
 	 */
 	getTypes(module) {
@@ -225,7 +233,7 @@ class ByTypeGenerator extends Generator {
 
 	/**
 	 * Returns the estimated size for the requested source type.
-	 * @param {NormalModule} module the module
+	 * @param {TModule} module the module
 	 * @param {SourceType=} type source type
 	 * @returns {number} estimate size of the module
 	 */
@@ -237,7 +245,7 @@ class ByTypeGenerator extends Generator {
 
 	/**
 	 * Generates generated code for this runtime module.
-	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {TModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
 	 * @returns {Source | null} generated code
 	 */

package/lib/module/Module.js

@@ -136,7 +136,7 @@ const {
  * @typedef {object} AllCodeGenerationSchemas
  * @property {Set<string>} topLevelDeclarations top level declarations for javascript modules
  * @property {Set<string>} freeNames free identifier names in the rendered source for javascript modules
- * @property {InitFragment<EXPECTED_ANY>[]} chunkInitFragments chunk init fragments for javascript modules
+ * @property {InitFragment<import("../javascript/JavascriptModulesPlugin").ChunkRenderContext>[]} chunkInitFragments chunk init fragments for javascript modules
  * @property {string} externalReexport native external reexport source and attributes
  * @property {string} exportsSource export definitions left out of a javascript module's source on demand (see `KnownMeta.onDemandExports`), to be placed before its body where it is wrapped
  * @property {string} exportsBindingSource export definitions left out on demand that read the module's own declarations, to be placed after its body where it is wrapped
@@ -1536,7 +1536,7 @@ Object.defineProperty(Module.prototype, "used", {
 	},
 	/**
 	 * Updates used using the provided value.
-	 * @param {EXPECTED_ANY} value value
+	 * @param {never} value value
 	 */
 	set(value) {
 		throw new Error(

package/lib/module/NormalModule.js

@@ -203,6 +203,7 @@ const DEPRECATED_PARSER_STATE_ALIASES = {
  * } from "./NormalModuleFactory"
  */
 /** @import Parser, { ParserState, PreparsedAst } from "./Parser" */
+/** @import { LoaderData, LoaderResultArgs } from "../loaders/LoaderRunner" */
 /**
  * @typedef {InstanceType<typeof import("../dependencies/esm/ESMExportImportedSpecifierDependency").ESMStarExportsList>} ESMStarExportsList
  */
@@ -290,7 +291,8 @@ const DEPRECATED_PARSER_STATE_ALIASES = {
 
 /**
  * @template T
- * @typedef {NormalModuleLoaderContext<T> & import("../loaders/LoaderRunner").LoaderRunnerLoaderContext<T> & import("../loaders/LoaderPlugin").LoaderPluginLoaderContext & import("../hmr/HotModuleReplacementPlugin").HotModuleReplacementPluginLoaderContext} LoaderContext
+ * @template [DataType=LoaderData]
+ * @typedef {NormalModuleLoaderContext<T> & import("../loaders/LoaderRunner").LoaderRunnerLoaderContext<T, DataType> & import("../loaders/LoaderPlugin").LoaderPluginLoaderContext & import("../hmr/HotModuleReplacementPlugin").HotModuleReplacementPluginLoaderContext} LoaderContext
  */
 
 /** @typedef {(content: string) => boolean} NoParseFn */
@@ -1163,7 +1165,7 @@ class NormalModule extends Module {
 		/** @type {NormalModuleLoaderContext<T>} */
 		const loaderContext = {
 			version: 2,
-			/** @type {LoaderContext<EXPECTED_ANY>["getOptions"]} */
+			/** @type {LoaderContext<T>["getOptions"]} */
 			getOptions: (/** @type {Schema=} */ schema = undefined) => {
 				const loader = this.getCurrentLoader(
 					/** @type {AnyLoaderContext} */
@@ -1411,7 +1413,7 @@ class NormalModule extends Module {
 
 		/**
 		 * @param {Error | null} err err
-		 * @param {(Result | null)=} result_ result
+		 * @param {(LoaderResultArgs | null)=} result_ result
 		 * @returns {void}
 		 */
 		const processResult = (err, result_) => {
@@ -1523,7 +1525,7 @@ class NormalModule extends Module {
 				/**
 				 * @param {AnyLoaderContext} loaderContext the loader context
 				 * @param {string} resourcePath the resource Path
-				 * @param {(err: Error | null, result?: string | Buffer, sourceMap?: Result[1]) => void} callback callback
+				 * @param {(err: Error | null, ...args: LoaderResultArgs) => void} callback callback
 				 * @returns {Promise<void>}
 				 */
 				processResource: async (loaderContext, resourcePath, callback) => {
@@ -1607,7 +1609,7 @@ class NormalModule extends Module {
 					loaderContext._compiler =
 					loaderContext._module =
 					loaderContext.fs =
-						/** @type {EXPECTED_ANY} */
+						/** @type {never} */
 						(undefined);
 
 				if (!result) {

package/lib/module/NormalModuleFactory.js

@@ -579,26 +579,28 @@ const ruleSetCompiler = new RuleSetCompiler([
  */
 /* eslint-enable jsdoc/type-formatting */
 
+/** @typedef {[string, Parser<never>, ParserOptions, Generator<never>, GeneratorOptions]} ParserAndGeneratorTuple */
+
 /**
  * Defines the extract tuple elements type used by this module.
- * @template {unknown[]} T
+ * @template {ParserAndGeneratorTuple} T
  * @template {number[]} I
  * @typedef {{ [K in keyof I]: K extends keyof I ? I[K] extends keyof T ? T[I[K]] : never : never }} ExtractTupleElements
  */
 
 /**
  * Represents the normal module factory runtime component.
- * @template {unknown[]} T
+ * @template {ParserAndGeneratorTuple[]} T
  * @template {number[]} A
  * @template [R=void]
- * @typedef {T extends [infer Head extends [string, ...unknown[]], ...infer Tail extends [string, ...unknown[]][]] ? Record<Head[0], SyncBailHook<ExtractTupleElements<Head, A>, R extends number ? Head[R] : R>> & RecordFactoryFromTuple<Tail, A, R> : unknown } RecordFactoryFromTuple
+ * @typedef {T extends [infer Head extends ParserAndGeneratorTuple] ? Record<Head[0], SyncBailHook<ExtractTupleElements<Head, A>, R extends number ? Head[R] : R>> : T extends [infer Head extends ParserAndGeneratorTuple, ...infer Tail extends ParserAndGeneratorTuple[]] ? Record<Head[0], SyncBailHook<ExtractTupleElements<Head, A>, R extends number ? Head[R] : R>> & RecordFactoryFromTuple<Tail, A, R> : never } RecordFactoryFromTuple
  */
 
 /**
  * Maps each tuple in `T` to a record from its `[0]` key to its `[I]` value.
- * @template {unknown[]} T
+ * @template {ParserAndGeneratorTuple[]} T
  * @template {number} I
- * @typedef {T extends [infer Head extends [string, ...unknown[]], ...infer Tail extends [string, ...unknown[]][]] ? Record<Head[0], I extends keyof Head ? Head[I] : never> & TupleToTypeMap<Tail, I> : unknown } TupleToTypeMap
+ * @typedef {T extends [infer Head extends ParserAndGeneratorTuple] ? Record<Head[0], I extends keyof Head ? Head[I] : never> : T extends [infer Head extends ParserAndGeneratorTuple, ...infer Tail extends ParserAndGeneratorTuple[]] ? Record<Head[0], I extends keyof Head ? Head[I] : never> & TupleToTypeMap<Tail, I> : never } TupleToTypeMap
  */
 
 /** @typedef {TupleToTypeMap<ParsersAndGeneratorsByTypes, 1>} ParserByType */
@@ -1604,12 +1606,8 @@ ${difference}`);
 				);
 				this.fs.readdir(directory, (err, entries) => {
 					if (!err && entries) {
-						return suggest(
-							prefix,
-							requestedName,
-							/** @type {string[]} */ (entries),
-							false,
-							() => next(index + 1)
+						return suggest(prefix, requestedName, entries, false, () =>
+							next(index + 1)
 						);
 					}
 					// The directory is missing, so only a directory the request spells
@@ -1624,12 +1622,8 @@ ${difference}`);
 						if (fixedPrefix === undefined) return next(index + 1);
 						this.fs.readdir(mismatch.path, (realError, realEntries) => {
 							if (realError || !realEntries) return next(index + 1);
-							suggest(
-								fixedPrefix,
-								requestedName,
-								/** @type {string[]} */ (realEntries),
-								true,
-								() => next(index + 1)
+							suggest(fixedPrefix, requestedName, realEntries, true, () =>
+								next(index + 1)
 							);
 						});
 					});

package/lib/module/Parser.js

@@ -17,16 +17,23 @@
 
 /**
  * Defines the parser state base type used by this module.
+ * @template {NormalModule} [TModule=NormalModule]
  * @typedef {object} ParserStateBase
  * @property {string | Buffer} source
  * @property {NormalModule} current
- * @property {NormalModule} module
+ * @property {TModule} module the module being parsed
  * @property {Compilation} compilation
  * @property {WebpackOptions} options
  */
 
-/** @typedef {ParserStateBase & Record<string, EXPECTED_ANY>} ParserState */
+/**
+ * @template {NormalModule} [TModule=NormalModule]
+ * @typedef {ParserStateBase<TModule> & Record<string, EXPECTED_ANY>} ParserState
+ */
 
+/**
+ * @template {NormalModule} [TModule=NormalModule] the module class this parser parses
+ */
 class Parser {
 	/* istanbul ignore next */
 	/**