webpack 5.111.1 → 5.112.1

package/lib/library/SystemLibraryPlugin.js

@@ -6,12 +6,12 @@
 "use strict";
 
 const { ConcatSource } = require("webpack-sources");
-const { UsageState } = require("../ExportsInfo");
-const ExternalModule = require("../ExternalModule");
-const Template = require("../Template");
+const { UsageState } = require("../graph/ExportsInfo");
+const Template = require("../template/Template");
 const { propertyAccess } = require("../util/property");
 const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 
+/** @import ExternalModule from "../externals/ExternalModule" */
 /** @import { Source } from "webpack-sources" */
 /**
  * @import {
@@ -19,9 +19,9 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
  * 	LibraryType
  * } from "../../declarations/WebpackOptions"
  */
-/** @import Chunk from "../Chunk" */
+/** @import Chunk from "../graph/Chunk" */
 /** @import { ChunkHashContext } from "../Compilation" */
-/** @import { ExportInfoName } from "../Dependency" */
+/** @import { ExportInfoName } from "../graph/Dependency" */
 /** @import { RenderContext } from "../javascript/JavascriptModulesPlugin" */
 /** @import Hash from "../util/Hash" */
 /**
@@ -87,9 +87,7 @@ class SystemLibraryPlugin extends AbstractLibraryPlugin {
 	render(source, { chunkGraph, moduleGraph, chunk }, { options, compilation }) {
 		const modules = chunkGraph
 			.getChunkModules(chunk)
-			.filter(
-				(m) => m instanceof ExternalModule && m.externalType === "system"
-			);
+			.filter((m) => m.is("external") && m.externalType === "system");
 		const externals = /** @type {ExternalModule[]} */ (modules);
 
 		// The name this bundle should be registered as with System

package/lib/library/UmdLibraryPlugin.js

@@ -6,8 +6,7 @@
 "use strict";
 
 const { ConcatSource, OriginalSource } = require("webpack-sources");
-const ExternalModule = require("../ExternalModule");
-const Template = require("../Template");
+const Template = require("../template/Template");
 const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 
 /** @import { Source } from "webpack-sources" */
@@ -21,7 +20,7 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
  * } from "../../declarations/WebpackOptions"
  */
 /** @import { RenderContext } from "../javascript/JavascriptModulesPlugin" */
-/** @import { RequestRecord } from "../ExternalModule" */
+/** @import ExternalModule, { RequestRecord } from "../externals/ExternalModule" */
 
 /**
  * Defines the shared type used by this module.
@@ -164,7 +163,7 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 			.getChunkModules(chunk)
 			.filter(
 				(m) =>
-					m instanceof ExternalModule &&
+					m.is("external") &&
 					(m.externalType === "umd" || m.externalType === "umd2")
 			);
 		let externals = /** @type {ExternalModule[]} */ (modules);

package/lib/{dependencies → loaders}/LoaderDependency.js

@@ -5,10 +5,10 @@
 
 "use strict";
 
-const ModuleDependency = require("./ModuleDependency");
+const ModuleDependency = require("../dependencies/core/ModuleDependency");
 
-/** @import { GetConditionFn } from "../Dependency" */
-/** @import ModuleGraph from "../ModuleGraph" */
+/** @import { GetConditionFn } from "../graph/Dependency" */
+/** @import ModuleGraph from "../graph/ModuleGraph" */
 
 class LoaderDependency extends ModuleDependency {
 	/**

package/lib/{dependencies → loaders}/LoaderImportDependency.js

@@ -5,10 +5,10 @@
 
 "use strict";
 
-const ModuleDependency = require("./ModuleDependency");
+const ModuleDependency = require("../dependencies/core/ModuleDependency");
 
-/** @import { GetConditionFn } from "../Dependency" */
-/** @import ModuleGraph from "../ModuleGraph" */
+/** @import { GetConditionFn, DependencyKinds } from "../graph/Dependency" */
+/** @import ModuleGraph from "../graph/ModuleGraph" */
 
 class LoaderImportDependency extends ModuleDependency {
 	/**
@@ -39,4 +39,10 @@ class LoaderImportDependency extends ModuleDependency {
 	}
 }
 
+/** @type {Set<keyof DependencyKinds>} */
+LoaderImportDependency.KINDS = new Set([
+	...ModuleDependency.KINDS,
+	"loader-import"
+]);
+
 module.exports = LoaderImportDependency;

package/lib/{LoaderOptionsPlugin.js → loaders/LoaderOptionsPlugin.js}

@@ -5,21 +5,39 @@
 
 "use strict";
 
-const ModuleFilenameHelpers = require("./ModuleFilenameHelpers");
-const NormalModule = require("./NormalModule");
+const ModuleFilenameHelpers = require("../devtool/ModuleFilenameHelpers");
+const NormalModule = require("../module/NormalModule");
+
+/** @import Compiler from "../Compiler" */
+/** @import { MatchObject } from "../devtool/ModuleFilenameHelpers" */
+
+/**
+ * @inline
+ * @absolutePath true
+ * @typedef {string} AbsolutePath
+ */
+
+/**
+ * A configuration object that can be used to configure older loaders.
+ * @additionalProperties
+ * @inline
+ * @typedef {object} LoaderOptionsPluginLoaderOptions
+ * @property {AbsolutePath=} context The context that can be used to configure older loaders.
+ */
 
 /**
- * @import {
- * 	LoaderOptionsPluginOptions
- * } from "../declarations/plugins/LoaderOptionsPlugin"
+ * @additionalProperties
+ * @schema plugins/LoaderOptionsPlugin
+ * @typedef {object} LoaderOptionsPluginOptions
+ * @property {boolean=} debug Whether loaders should be in debug mode or not. debug will be removed as of webpack 3.
+ * @property {boolean=} minimize Where loaders can be switched to minimize mode.
+ * @property {LoaderOptionsPluginLoaderOptions & Record<string, EXPECTED_ANY>=} options
  */
-/** @import Compiler from "./Compiler" */
-/** @import { MatchObject } from "./ModuleFilenameHelpers" */
 
 /**
  * Defines the loader context type used by this module.
  * @template T
- * @typedef {import("./NormalModule").LoaderContext<T>} LoaderContext
+ * @typedef {import("../module/NormalModule").LoaderContext<T>} LoaderContext
  */
 
 const PLUGIN_NAME = "LoaderOptionsPlugin";
@@ -27,7 +45,7 @@ const PLUGIN_NAME = "LoaderOptionsPlugin";
 class LoaderOptionsPlugin {
 	/**
 	 * Creates an instance of LoaderOptionsPlugin.
-	 * @param {LoaderOptionsPluginOptions & MatchObject} options options object
+	 * @param {LoaderOptionsPluginOptions & MatchObject & Record<string, EXPECTED_ANY>} options options object
 	 */
 	constructor(options = {}) {
 		// If no options are set then generate empty options object
@@ -35,7 +53,7 @@ class LoaderOptionsPlugin {
 		if (!options.test) {
 			options.test = () => true;
 		}
-		/** @type {LoaderOptionsPluginOptions & MatchObject} */
+		/** @type {LoaderOptionsPluginOptions & MatchObject & Record<string, EXPECTED_ANY>} */
 		this.options = options;
 	}
 
@@ -47,14 +65,14 @@ class LoaderOptionsPlugin {
 	apply(compiler) {
 		compiler.hooks.validate.tap(PLUGIN_NAME, () => {
 			compiler.validate(
-				() => require("../schemas/plugins/LoaderOptionsPlugin.json"),
+				() => require("../../schemas/plugins/LoaderOptionsPlugin.json"),
 				this.options,
 				{
 					name: "Loader Options Plugin",
 					baseDataPath: "options"
 				},
 				(options) =>
-					require("../schemas/plugins/LoaderOptionsPlugin.check")(options)
+					require("../../schemas/plugins/LoaderOptionsPlugin.check")(options)
 			);
 		});
 

package/lib/{dependencies → loaders}/LoaderPlugin.js

@@ -5,8 +5,8 @@
 
 "use strict";
 
-const NormalModule = require("../NormalModule");
 const { markNotCacheable } = require("../loaders/LoaderRunner");
+const NormalModule = require("../module/NormalModule");
 const LazySet = require("../util/LazySet");
 const LoaderDependency = require("./LoaderDependency");
 const LoaderImportDependency = require("./LoaderImportDependency");
@@ -21,7 +21,7 @@ const LoaderImportDependency = require("./LoaderImportDependency");
  * } from "../Compilation"
  */
 /** @import Compiler from "../Compiler" */
-/** @import Module, { BuildInfo } from "../Module" */
+/** @import Module, { BuildInfo } from "../module/Module" */
 
 /**
  * Defines the import module callback callback.

package/lib/loaders/LoaderRunner.js

@@ -12,32 +12,46 @@ const loadLoader = require("./loadLoader");
 
 /** @import { RawSourceMap } from "webpack-sources" */
 /** @import { Environment } from "../../declarations/WebpackOptions" */
+/** @import { PreparsedAst } from "../module/Parser" */
+/** @import { LoaderItem } from "../module/NormalModule" */
 
 // Set on a loader context to have each loader's own run measured. Absent
 // unless something asked for the measurement, and read once per loader.
 const LOADER_TIMING = Symbol("loader timing");
 
-/** @typedef {string | ({ loader: string } & Record<string, EXPECTED_ANY>)} LoaderItemInput */
+/** @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
@@ -45,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 {EXPECTED_OBJECT} 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 */
@@ -64,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 {EXPECTED_OBJECT | string | undefined} options
+ * @property {string | null | undefined | OptionsType} options
  * @property {string} ident
- * @property {EXPECTED_FUNCTION | undefined} normal
- * @property {EXPECTED_FUNCTION | undefined} pitch
+ * @property {LoaderDefinitionFunction<OptionsType> | RawLoaderDefinitionFunction<OptionsType> | undefined} normal
+ * @property {PitchLoaderDefinitionFunction<OptionsType> | undefined} pitch
  * @property {boolean | undefined} raw
- * @property {EXPECTED_OBJECT | undefined} data
+ * @property {DataType | undefined} data
  * @property {boolean} pitchExecuted
  * @property {boolean} normalExecuted
  * @property {("commonjs" | "module")=} type
@@ -84,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
  */
 
 /**
@@ -132,25 +157,26 @@ 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("../NormalModule").LoaderContext<OptionsType> & ContextAdditions, remainingRequest: string, previousRequest: string, data: EXPECTED_OBJECT) => 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
  */
 
 /**
  * @template [OptionsType={}]
  * @template [ContextAdditions={}]
- * @typedef {(this: import("../NormalModule").LoaderContext<OptionsType> & ContextAdditions, content: string, sourceMap?: string | RawSourceMap, additionalData?: AdditionalData) => string | Buffer | Promise<string | Buffer> | void} LoaderDefinitionFunction
+ * @typedef {(this: import("../module/NormalModule").LoaderContext<OptionsType> & ContextAdditions, content: string, sourceMap?: string | RawSourceMap, additionalData?: AdditionalData) => string | Buffer | Promise<string | Buffer> | void} LoaderDefinitionFunction
  */
 
 /**
  * @template [OptionsType={}]
  * @template [ContextAdditions={}]
- * @typedef {(this: import("../NormalModule").LoaderContext<OptionsType> & ContextAdditions, content: Buffer, sourceMap?: string | RawSourceMap, additionalData?: AdditionalData) => string | Buffer | Promise<string | Buffer> | void} RawLoaderDefinitionFunction
+ * @typedef {(this: import("../module/NormalModule").LoaderContext<OptionsType> & ContextAdditions, content: Buffer, sourceMap?: string | RawSourceMap, additionalData?: AdditionalData) => string | Buffer | Promise<string | Buffer> | void} RawLoaderDefinitionFunction
  */
 
 /**
@@ -179,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
@@ -256,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=} */
+		/** @type {(string | null)=} */
 		this.type = undefined;
-		/** @type {EXPECTED_FUNCTION | null=} */
+		/** @type {LoaderDefinitionFunction<LoaderOptions> | RawLoaderDefinitionFunction<LoaderOptions> | null=} */
 		this.normal = null;
-		/** @type {EXPECTED_FUNCTION | null=} */
+		/** @type {PitchLoaderDefinitionFunction<LoaderOptions> | null=} */
 		this.pitch = null;
 		/** @type {boolean | null=} */
 		this.raw = null;
-		/** @type {EXPECTED_OBJECT | null=} */
+		/** @type {LoaderData | null=} */
 		this.data = null;
 		this.pitchExecuted = false;
 		this.normalExecuted = false;
@@ -338,9 +368,9 @@ const REQUEST_DESCRIPTOR = {
 };
 
 /**
- * @param {EXPECTED_FUNCTION} 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}
  */
@@ -351,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) {
@@ -383,17 +413,22 @@ function runSyncOrAsync(fn, context, args, callback) {
 		return innerCallback;
 	};
 
+	// The runner types its context more loosely than a loader's `this`.
+	const loader =
+		/** @type {(this: LoaderContext, ...args: LoaderResultArgs | PitchArgs) => ReturnType<LoaderDefinitionFunction>} */ (
+			fn
+		);
 	const timing =
-		/** @type {{ [LOADER_TIMING]?: (loader: EXPECTED_ANY, run: () => EXPECTED_ANY) => EXPECTED_ANY }} */
+		/** @type {{ [LOADER_TIMING]?: <T>(loader: LoaderObject, run: () => T) => T }} */
 		(context)[LOADER_TIMING];
 
 	try {
 		const result = (function LOADER_EXECUTION() {
 			return timing
 				? timing(context.loaders[context.loaderIndex], () =>
-						fn.apply(context, args)
+						loader.apply(context, args)
 					)
-				: fn.apply(context, args);
+				: loader.apply(context, args);
 		})();
 		if (isSync) {
 			isDone = true;
@@ -401,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;
@@ -429,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}
@@ -454,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}
  */
@@ -497,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) {
@@ -515,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) {
@@ -626,7 +666,9 @@ const LOADER_STATE = Symbol("loader context state");
  * @returns {LoaderState} the hidden mutable state carried under `LOADER_STATE`
  */
 function getState(loaderContext) {
-	return /** @type {EXPECTED_ANY} */ (loaderContext)[LOADER_STATE];
+	return /** @type {LoaderContext & { [LOADER_STATE]: LoaderState }} */ (
+		loaderContext
+	)[LOADER_STATE];
 }
 
 /**
@@ -636,7 +678,8 @@ function getState(loaderContext) {
  * and the `request` accessors once host hooks have populated the context, then
  * freezes it — the accessors are added last so V8 keeps the context in
  * fast-properties mode. Returned unfrozen.
- * @param {EXPECTED_ANY=} base object to augment (the caller's context), if any
+ * @template T
+ * @param {T=} base object to augment (the caller's context), if any
  * @returns {LoaderContext} the loader context
  */
 function createLoaderContext(base) {
@@ -703,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}
  */
@@ -805,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}
  */
@@ -816,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 = /** @type {EXPECTED_ANY} */ (options.context);
+	const provided =
+		/** @type {{ [LOADER_STATE]?: LoaderState } | undefined} */
+		(options.context);
 	const loaderContext =
 		provided && provided[LOADER_STATE]
 			? /** @type {LoaderContext} */ (provided)
@@ -841,8 +888,9 @@ module.exports.runLoaders = function runLoaders(options, callback) {
 	);
 
 	const processResourceFn =
-		options.processResource ||
-		/** @type {(readResource: EXPECTED_FUNCTION, context: EXPECTED_ANY, res: string, cb: (err: Error | null, ...args: EXPECTED_ANY[]) => 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/{LoaderTargetPlugin.js → loaders/LoaderTargetPlugin.js}

@@ -5,9 +5,9 @@
 
 "use strict";
 
-const NormalModule = require("./NormalModule");
+const NormalModule = require("../module/NormalModule");
 
-/** @import Compiler from "./Compiler" */
+/** @import Compiler from "../Compiler" */
 
 const PLUGIN_NAME = "LoaderTargetPlugin";
 

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));
 		}