webpack 5.111.0 → 5.112.0

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("../declarations/LoaderContext").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 { BuildInfo } from "../Module" */
+/** @import Module, { BuildInfo } from "../module/Module" */
 
 /**
  * Defines the import module callback callback.
@@ -39,6 +39,31 @@ const LoaderImportDependency = require("./LoaderImportDependency");
  * @property {string=} baseUri target base uri
  */
 
+/**
+ * @callback LoadModuleCallback
+ * @param {Error | null} err error object
+ * @param {(string | Buffer)=} source source of the loaded module
+ * @param {(object | null)=} sourceMap source map of the loaded module
+ * @param {Module=} module the loaded module
+ * @returns {void}
+ */
+
+/**
+ * `importModule` takes a callback or, given none, answers with a promise, and
+ * TypeScript reads an intersection of call signatures as an overload set
+ * @typedef {{ (request: string, options: ImportModuleOptions | undefined, callback: ImportModuleCallback): void } & { (request: string, options?: ImportModuleOptions): Promise<ExecuteModuleExports> }} ImportModuleMethod
+ */
+
+/**
+ * These properties are added by the LoaderPlugin
+ * @typedef {object} LoaderPluginLoaderContext
+ * @property {(request: string, callback: LoadModuleCallback) => void} loadModule Resolves the given request to a module, applies all configured loaders and calls
+ * back with the generated source, the sourceMap and the module instance (usually an
+ * instance of NormalModule). Use this function if you need to know the source code
+ * of another module to generate the result.
+ * @property {ImportModuleMethod} importModule
+ */
+
 const PLUGIN_NAME = "LoaderPlugin";
 
 class LoaderPlugin {

package/lib/loaders/LoaderRunner.js

@@ -10,11 +10,16 @@ const { parseResource } = require("../util/identifier");
 const { adjustSourceMapForRemovedBOM } = require("../util/removeBOM");
 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 */
 
 /**
  * @typedef {object} ProcessOptions
@@ -44,14 +49,139 @@ const LOADER_TIMING = Symbol("loader timing");
 
 /** @typedef {(...args: EXPECTED_ANY[]) => void} LoaderCallback */
 
-/** @typedef {import("../../declarations/LoaderContext").LoaderRunnerLoaderContext<EXPECTED_ANY>} LoaderRunnerLoaderContext */
+/**
+ * @typedef {object} AdditionalDataKnown
+ * @property {PreparsedAst} webpackAST the AST webpack should parse instead of the source
+ */
+
+/** @typedef {AdditionalDataKnown & Record<string, EXPECTED_ANY>} AdditionalData */
+
+/**
+ * @callback WebpackLoaderContextCallback
+ * @param {undefined | null | Error} err error object
+ * @param {(string | Buffer)=} content the loader result
+ * @param {(null | string | RawSourceMap)=} sourceMap a source map for the result
+ * @param {AdditionalData=} additionalData data passed to the next loader
+ * @returns {void}
+ */
+
+/**
+ * @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} ident
+ * @property {LoaderDefinitionFunction<EXPECTED_ANY> | RawLoaderDefinitionFunction<EXPECTED_ANY> | undefined} normal
+ * @property {PitchLoaderDefinitionFunction<EXPECTED_ANY> | undefined} pitch
+ * @property {boolean | undefined} raw
+ * @property {Record<string, EXPECTED_ANY> | undefined} data
+ * @property {boolean} pitchExecuted
+ * @property {boolean} normalExecuted
+ * @property {("commonjs" | "module")=} type
+ */
+
+/**
+ * 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 OptionsType
+ * @typedef {object} LoaderRunnerMutableContext
+ * @property {(context: string) => void} addContextDependency Add a directory as dependency of the loader result.
+ * @property {(file: string) => void} addDependency Adds a file as dependency of the loader result in order to make them watchable.
+ * For example, html-loader uses this technique as it finds src and src-set attributes.
+ * Then, it sets the url's for those attributes as dependencies of the html file that is parsed.
+ * @property {(context: string) => void} addMissingDependency
+ * @property {() => WebpackLoaderContextCallback} async Make this loader async.
+ * @property {(flag?: boolean) => void} cacheable Make this loader result cacheable. By default it's cacheable.
+ * A cacheable loader must have a deterministic result, when inputs and dependencies haven't changed.
+ * This means the loader shouldn't have other dependencies than specified with this.addDependency.
+ * Most loaders are deterministic and cacheable.
+ * @property {WebpackLoaderContextCallback} callback
+ * @property {() => void} clearDependencies Remove all dependencies of the loader result. Even initial dependencies and these of other loaders.
+ * @property {string} context The directory of the module. Can be used as context for resolving other stuff.
+ * eg '/workspaces/ts-loader/examples/vanilla/src'
+ * @property {(file: string) => void} dependency alias of addDependency
+ * Adds a file as dependency of the loader result in order to make them watchable.
+ * For example, html-loader uses this technique as it finds src and src-set attributes.
+ * Then, it sets the url's for those attributes as dependencies of the html file that is parsed.
+ * @property {() => string[]} getContextDependencies
+ * @property {() => string[]} getDependencies
+ * @property {() => string[]} getMissingDependencies
+ * @property {number} loaderIndex The index in the loaders array of the current loader.
+ * In the example: in loader1: 0, in loader2: 1
+ * @property {LoaderEntry[]} loaders An array of all the loaders. It is writeable in the pitch phase.
+ * loaders = [{request: string, path: string, query: string, module: function}]
+ * @property {string} resourcePath The resource path.
+ * In the example: "/abc/resource.js"
+ * @property {string} resourceQuery The resource query string.
+ * Example: "?query"
+ * @property {string} resourceFragment The resource fragment.
+ * Example: "#frag"
+ * @property {string} resource The resource inclusive query and fragment.
+ * Example: "/abc/resource.js?query#frag"
+ * @property {string} target Target of compilation.
+ * Example: "web"
+ * @property {Environment} environment Tell what kind of ES-features may be used in the generated runtime-code.
+ * Example: { arrowFunction: true }
+ */
+
+/**
+ * The properties are added by https://github.com/webpack/loader-runner
+ * @template OptionsType
+ * @typedef {LoaderRunnerMutableContext<OptionsType> & LoaderRunnerReadonlyContext<OptionsType>} 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
+ */
+
+/**
+ * @template [OptionsType={}]
+ * @template [ContextAdditions={}]
+ * @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("../module/NormalModule").LoaderContext<OptionsType> & ContextAdditions, content: Buffer, sourceMap?: string | RawSourceMap, additionalData?: AdditionalData) => string | Buffer | Promise<string | Buffer> | void} RawLoaderDefinitionFunction
+ */
+
+/**
+ * @template [OptionsType={}]
+ * @template [ContextAdditions={}]
+ * @typedef {LoaderDefinitionFunction<OptionsType, ContextAdditions> & { raw?: false, pitch?: PitchLoaderDefinitionFunction<OptionsType, ContextAdditions> }} LoaderDefinition
+ */
+
+/**
+ * @template [OptionsType={}]
+ * @template [ContextAdditions={}]
+ * @typedef {RawLoaderDefinitionFunction<OptionsType, ContextAdditions> & { raw: true, pitch?: PitchLoaderDefinitionFunction<OptionsType, ContextAdditions> }} RawLoaderDefinition
+ */
+
+/**
+ * @template [OptionsType={}]
+ * @template [ContextAdditions={}]
+ * @typedef {object} LoaderModule
+ * @property {(RawLoaderDefinitionFunction<OptionsType, ContextAdditions> | LoaderDefinitionFunction<OptionsType, ContextAdditions>)=} default
+ * @property {false=} raw
+ * @property {PitchLoaderDefinitionFunction<OptionsType, ContextAdditions>=} pitch
+ */
 
 /**
  * The loader context as the runner sees and mutates it: the canonical
  * `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, "context" | "callback" | "async" | "loaders"> & { context: string | null, callback: LoaderCallback | null, async: (() => LoaderCallback | undefined) | null, loaders: LoaderObject[] }} LoaderContext
+ * @typedef {Omit<LoaderRunnerLoaderContext<EXPECTED_ANY>, "context" | "callback" | "async" | "loaders"> & { context: string | null, callback: LoaderCallback | null, async: (() => LoaderCallback | undefined) | null, loaders: LoaderObject[] }} LoaderContext
  */
 
 const HASH_ESCAPE_REGEXP = /#/g;
@@ -132,15 +262,15 @@ class LoaderObject {
 		this.options = null;
 		/** @type {string | null=} */
 		this.ident = null;
-		/** @type {string=} */
+		/** @type {(string | null)=} */
 		this.type = undefined;
-		/** @type {EXPECTED_FUNCTION | null=} */
+		/** @type {LoaderDefinitionFunction<EXPECTED_ANY> | RawLoaderDefinitionFunction<EXPECTED_ANY> | null=} */
 		this.normal = null;
-		/** @type {EXPECTED_FUNCTION | null=} */
+		/** @type {PitchLoaderDefinitionFunction<EXPECTED_ANY> | null=} */
 		this.pitch = null;
 		/** @type {boolean | null=} */
 		this.raw = null;
-		/** @type {EXPECTED_OBJECT | null=} */
+		/** @type {Record<string, EXPECTED_ANY> | null=} */
 		this.data = null;
 		this.pitchExecuted = false;
 		this.normalExecuted = false;
@@ -210,7 +340,7 @@ const REQUEST_DESCRIPTOR = {
 };
 
 /**
- * @param {EXPECTED_FUNCTION} fn the loader function
+ * @param {LoaderDefinitionFunction<EXPECTED_ANY> | RawLoaderDefinitionFunction<EXPECTED_ANY> | PitchLoaderDefinitionFunction<EXPECTED_ANY>} fn the loader function
  * @param {LoaderContext} context the loader context
  * @param {EXPECTED_ANY[]} args arguments
  * @param {LoaderCallback} callback callback
@@ -255,17 +385,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: EXPECTED_ANY[]) => EXPECTED_ANY} */ (
+			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;
@@ -498,7 +633,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];
 }
 
 /**
@@ -508,7 +645,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) {
@@ -575,7 +713,7 @@ 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} loaderContext loader context
+ * @param {LoaderRunnerLoaderContext<EXPECTED_ANY>} loaderContext loader context
  * @param {string[]} reasons reasons why the request is not cacheable
  * @returns {void}
  */
@@ -682,13 +820,13 @@ const ACCESSORS = {
  * @returns {void}
  */
 module.exports.runLoaders = function runLoaders(options, callback) {
-	// reuse a context already prepared by createLoaderContext (e.g. from
-	// NormalModule), else augment the caller-provided context (or a fresh object)
-	// in place. State is intentionally preserved across the handoff, so host hooks
-	// (e.g. 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 dependencies.
-	const provided = /** @type {EXPECTED_ANY} */ (options.context);
+	// WHY: reuse a context `createLoaderContext` already prepared, from
+	// NormalModule say, else augment the caller-provided context, or a fresh
+	// object, in place. State is intentionally preserved across the handoff, so a
+	// 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 loaderContext =
 		provided && provided[LOADER_STATE]
 			? /** @type {LoaderContext} */ (provided)
@@ -714,7 +852,7 @@ 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 {(readResource: NonNullable<RunLoaderOptions["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/logging/Logger.js

@@ -38,11 +38,11 @@ const TIMERS_AGGREGATES_SYMBOL = Symbol("webpack logger aggregated times");
 
 /** @typedef {EXPECTED_ANY[]} Args */
 /** @typedef {(type: LogTypeEnum, args?: Args) => void} LogFn */
-/** @typedef {(name: string | (() => string)) => WebpackLogger} GetChildLogger */
+/** @typedef {(name: string | (() => string)) => Logger} GetChildLogger */
 
-class WebpackLogger {
+class Logger {
 	/**
-	 * Creates an instance of WebpackLogger.
+	 * Creates an instance of Logger.
 	 * @param {LogFn} log log function
 	 * @param {GetChildLogger} getChildLogger function to create child logger
 	 */
@@ -173,7 +173,7 @@ class WebpackLogger {
 	timeLog(label) {
 		const prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
 		if (!prev) {
-			throw new Error(`No such label '${label}' for WebpackLogger.timeLog()`);
+			throw new Error(`No such label '${label}' for Logger.timeLog()`);
 		}
 		const time = process.hrtime(prev);
 		this[LOG_SYMBOL](LogType.time, [label, ...time]);
@@ -186,7 +186,7 @@ class WebpackLogger {
 	timeEnd(label) {
 		const prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
 		if (!prev) {
-			throw new Error(`No such label '${label}' for WebpackLogger.timeEnd()`);
+			throw new Error(`No such label '${label}' for Logger.timeEnd()`);
 		}
 		const time = process.hrtime(prev);
 		/** @type {TimersMap} */
@@ -201,9 +201,7 @@ class WebpackLogger {
 	timeAggregate(label) {
 		const prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
 		if (!prev) {
-			throw new Error(
-				`No such label '${label}' for WebpackLogger.timeAggregate()`
-			);
+			throw new Error(`No such label '${label}' for Logger.timeAggregate()`);
 		}
 		const time = process.hrtime(prev);
 		/** @type {TimersMap} */
@@ -237,4 +235,4 @@ class WebpackLogger {
 	}
 }
 
-module.exports.Logger = WebpackLogger;
+module.exports.Logger = Logger;