@depup/webpack 5.106.1-depup.0 → 5.109.2-depup.0

package/lib/NormalModuleFactory.js

@@ -5,7 +5,6 @@
 
 "use strict";
 
-const { getContext } = require("loader-runner");
 const asyncLib = require("neo-async");
 const {
 	AsyncSeriesBailHook,
@@ -21,6 +20,7 @@ const ModuleGraph = require("./ModuleGraph");
 const { JAVASCRIPT_MODULE_TYPE_AUTO } = require("./ModuleTypeConstants");
 const NormalModule = require("./NormalModule");
 const { ImportPhaseUtils } = require("./dependencies/ImportPhase");
+const { getContext } = require("./loaders/LoaderRunner");
 const BasicEffectRulePlugin = require("./rules/BasicEffectRulePlugin");
 const BasicMatcherRulePlugin = require("./rules/BasicMatcherRulePlugin");
 const ObjectMatcherRulePlugin = require("./rules/ObjectMatcherRulePlugin");
@@ -31,6 +31,7 @@ const { getScheme } = require("./util/URLAbsoluteSpecifier");
 const { cachedCleverMerge, cachedSetProperty } = require("./util/cleverMerge");
 const { join } = require("./util/fs");
 const {
+	escapeHashInPathRequest,
 	parseResource,
 	parseResourceWithoutFragment
 } = require("./util/identifier");
@@ -62,14 +63,16 @@ const {
 /** @typedef {import("./util/identifier").AssociatedObjectForCache} AssociatedObjectForCache */
 
 /**
+ * Defines the callback type used by this module.
  * @template T
  * @typedef {import("./Compiler").Callback<T>} Callback
  */
 
 /** @typedef {Pick<RuleSetRule, "type" | "sideEffects" | "parser" | "generator" | "resolve" | "layer" | "extractSourceMap">} ModuleSettings */
-/** @typedef {Partial<NormalModuleCreateData & { settings: ModuleSettings }>} CreateData */
+/** @typedef {NormalModuleCreateData & { settings: ModuleSettings }} CreateData */
 
 /**
+ * Defines the resolve data type used by this module.
  * @typedef {object} ResolveData
  * @property {ModuleFactoryCreateData["contextInfo"]} contextInfo
  * @property {ModuleFactoryCreateData["resolveOptions"]} resolveOptions
@@ -79,7 +82,7 @@ const {
  * @property {ImportAttributes=} attributes
  * @property {ModuleDependency[]} dependencies
  * @property {string} dependencyType
- * @property {CreateData} createData
+ * @property {Partial<CreateData>} createData
  * @property {FileSystemDependencies} fileDependencies
  * @property {FileSystemDependencies} missingDependencies
  * @property {FileSystemDependencies} contextDependencies
@@ -88,6 +91,7 @@ const {
  */
 
 /**
+ * Defines the resource data type used by this module.
  * @typedef {object} ResourceData
  * @property {string} resource
  * @property {string=} path
@@ -97,6 +101,7 @@ const {
  */
 
 /**
+ * Defines the resource scheme data type used by this module.
  * @typedef {object} ResourceSchemeData
  * @property {string=} mimetype mime type of the resource
  * @property {string=} parameters additional parameters for the resource
@@ -107,11 +112,25 @@ const {
 /** @typedef {ResourceData & { data: ResourceSchemeData & Partial<ResolveRequest> }} ResourceDataWithData */
 
 /**
+ * Defines the parsed loader request type used by this module.
  * @typedef {object} ParsedLoaderRequest
  * @property {string} loader loader
  * @property {string | undefined} options options
  */
 
+/**
+ * Dependencies captured while resolving a loader.
+ * @typedef {object} ResolveDependencies
+ * @property {LazySet<string>} fileDependencies file dependencies of the resolve
+ * @property {LazySet<string>} contextDependencies context dependencies of the resolve
+ * @property {LazySet<string>} missingDependencies missing dependencies of the resolve
+ */
+
+/**
+ * Memoized result of resolving a loader for a given (context, request).
+ * @typedef {ResolveDependencies & { loader: string, query: string | undefined, type: string | undefined }} LoaderResolveCacheEntry
+ */
+
 /** @typedef {import("./ModuleTypeConstants").JAVASCRIPT_MODULE_TYPE_AUTO} JAVASCRIPT_MODULE_TYPE_AUTO */
 /** @typedef {import("./ModuleTypeConstants").JAVASCRIPT_MODULE_TYPE_DYNAMIC} JAVASCRIPT_MODULE_TYPE_DYNAMIC */
 /** @typedef {import("./ModuleTypeConstants").JAVASCRIPT_MODULE_TYPE_ESM} JAVASCRIPT_MODULE_TYPE_ESM */
@@ -127,8 +146,9 @@ const {
 /** @typedef {import("./ModuleTypeConstants").CSS_MODULE_TYPE_GLOBAL} CSS_MODULE_TYPE_GLOBAL */
 /** @typedef {import("./ModuleTypeConstants").CSS_MODULE_TYPE_MODULE} CSS_MODULE_TYPE_MODULE */
 /** @typedef {import("./ModuleTypeConstants").CSS_MODULE_TYPE_AUTO} CSS_MODULE_TYPE_AUTO */
+/** @typedef {import("./ModuleTypeConstants").HTML_MODULE_TYPE} HTML_MODULE_TYPE */
 
-/** @typedef {JAVASCRIPT_MODULE_TYPE_AUTO | JAVASCRIPT_MODULE_TYPE_DYNAMIC | JAVASCRIPT_MODULE_TYPE_ESM | JSON_MODULE_TYPE | ASSET_MODULE_TYPE | ASSET_MODULE_TYPE_INLINE | ASSET_MODULE_TYPE_RESOURCE | ASSET_MODULE_TYPE_SOURCE | WEBASSEMBLY_MODULE_TYPE_ASYNC | WEBASSEMBLY_MODULE_TYPE_SYNC | CSS_MODULE_TYPE | CSS_MODULE_TYPE_GLOBAL | CSS_MODULE_TYPE_MODULE | CSS_MODULE_TYPE_AUTO} KnownNormalModuleTypes */
+/** @typedef {JAVASCRIPT_MODULE_TYPE_AUTO | JAVASCRIPT_MODULE_TYPE_DYNAMIC | JAVASCRIPT_MODULE_TYPE_ESM | JSON_MODULE_TYPE | ASSET_MODULE_TYPE | ASSET_MODULE_TYPE_INLINE | ASSET_MODULE_TYPE_RESOURCE | ASSET_MODULE_TYPE_SOURCE | WEBASSEMBLY_MODULE_TYPE_ASYNC | WEBASSEMBLY_MODULE_TYPE_SYNC | CSS_MODULE_TYPE | CSS_MODULE_TYPE_GLOBAL | CSS_MODULE_TYPE_MODULE | CSS_MODULE_TYPE_AUTO | HTML_MODULE_TYPE} KnownNormalModuleTypes */
 /** @typedef {KnownNormalModuleTypes | string} NormalModuleTypes */
 
 const EMPTY_RESOLVE_OPTIONS = {};
@@ -143,6 +163,26 @@ const MATCH_RESOURCE_REGEX = /^([^!]+)!=!/;
 const LEADING_DOT_EXTENSION_REGEX = /^[^.]/;
 
 /**
+ * Replays the file/context/missing dependencies captured by a loader resolve
+ * into a resolve context, so memoized loaders still record everything needed
+ * for watch invalidation.
+ * @param {ResolveContext} resolveContext resolve context to add dependencies to
+ * @param {ResolveDependencies} source captured resolve dependencies
+ * @returns {void}
+ */
+const replayResolveDependencies = (resolveContext, source) => {
+	// On this path resolveContext always carries the three LazySet dependency
+	// sets built in the `resolve` hook, so they are safe to treat as LazySet.
+	/** @type {LazySet<string>} */
+	(resolveContext.fileDependencies).addAll(source.fileDependencies);
+	/** @type {LazySet<string>} */
+	(resolveContext.contextDependencies).addAll(source.contextDependencies);
+	/** @type {LazySet<string>} */
+	(resolveContext.missingDependencies).addAll(source.missingDependencies);
+};
+
+/**
+ * Returns ident.
  * @param {LoaderItem} data data
  * @returns {string} ident
  */
@@ -163,6 +203,7 @@ const loaderToIdent = (data) => {
 };
 
 /**
+ * Stringify loaders and resource.
  * @param {LoaderItem[]} loaders loaders
  * @param {string} resource resource
  * @returns {string} stringified loaders and resource
@@ -176,6 +217,7 @@ const stringifyLoadersAndResource = (loaders, resource) => {
 };
 
 /**
+ * Checks whether it needs calls.
  * @param {number} times times
  * @param {(err?: null | Error) => void} callback callback
  * @returns {(err?: null | Error) => void} callback
@@ -191,6 +233,7 @@ const needCalls = (times, callback) => (err) => {
 };
 
 /**
+ * Merges global options.
  * @template T
  * @template O
  * @param {T} globalOptions global options
@@ -221,6 +264,7 @@ const mergeGlobalOptions = (globalOptions, type, localOptions) => {
 
 // TODO webpack 6 remove
 /**
+ * Deprecation changed hook message.
  * @template {import("tapable").Hook<EXPECTED_ANY, EXPECTED_ANY>} T
  * @param {string} name name
  * @param {T} hook hook
@@ -309,8 +353,14 @@ const ruleSetCompiler = new RuleSetCompiler([
 /** @typedef {import("../declarations/WebpackOptions").CssGeneratorOptions} CssGeneratorOptions */
 /** @typedef {import("../declarations/WebpackOptions").CssModuleGeneratorOptions} CssModuleGeneratorOptions */
 
+/** @typedef {import("./html/HtmlParser")} HtmlParser */
+/** @typedef {import("../declarations/WebpackOptions").EmptyParserOptions} HtmlParserOptions */
+/** @typedef {import("./html/HtmlGenerator")} HtmlGenerator */
+/** @typedef {import("../declarations/WebpackOptions").HtmlGeneratorOptions} HtmlGeneratorOptions */
+
 /* eslint-disable jsdoc/type-formatting */
 /**
+ * Defines the shared type used by this module.
  * @typedef {[
  * [JAVASCRIPT_MODULE_TYPE_AUTO, JavascriptParser, JavascriptParserOptions, JavascriptGenerator, EmptyGeneratorOptions],
  * [JAVASCRIPT_MODULE_TYPE_DYNAMIC, JavascriptParser, JavascriptParserOptions, JavascriptGenerator, EmptyGeneratorOptions],
@@ -321,32 +371,48 @@ const ruleSetCompiler = new RuleSetCompiler([
  * [ASSET_MODULE_TYPE_RESOURCE, AssetParser, EmptyParserOptions, AssetGenerator, AssetGeneratorOptions],
  * [ASSET_MODULE_TYPE_SOURCE, AssetSourceParser, EmptyParserOptions, AssetSourceGenerator, EmptyGeneratorOptions],
  * [ASSET_MODULE_TYPE_BYTES, AssetBytesParser, EmptyParserOptions, AssetBytesGenerator, EmptyGeneratorOptions],
- * [WEBASSEMBLY_MODULE_TYPE_ASYNC, AsyncWebAssemblyParser, EmptyParserOptions, Generator, EmptyParserOptions],
- * [WEBASSEMBLY_MODULE_TYPE_SYNC, WebAssemblyParser, EmptyParserOptions, Generator, EmptyParserOptions],
+ * [WEBASSEMBLY_MODULE_TYPE_ASYNC, AsyncWebAssemblyParser, EmptyParserOptions, Generator, EmptyGeneratorOptions],
+ * [WEBASSEMBLY_MODULE_TYPE_SYNC, WebAssemblyParser, EmptyParserOptions, Generator, EmptyGeneratorOptions],
  * [CSS_MODULE_TYPE, CssParser, CssParserOptions, CssGenerator, CssGeneratorOptions],
  * [CSS_MODULE_TYPE_AUTO, CssParser, CssModuleParserOptions, CssGenerator, CssModuleGeneratorOptions],
  * [CSS_MODULE_TYPE_MODULE, CssParser, CssModuleParserOptions, CssGenerator, CssModuleGeneratorOptions],
  * [CSS_MODULE_TYPE_GLOBAL, CssParser, CssModuleParserOptions, CssGenerator, CssModuleGeneratorOptions],
+ * [HTML_MODULE_TYPE, HtmlParser, HtmlParserOptions, HtmlGenerator, HtmlGeneratorOptions],
  * [string, Parser, ParserOptions, Generator, GeneratorOptions],
  * ]} ParsersAndGeneratorsByTypes
  */
 /* eslint-enable jsdoc/type-formatting */
 
 /**
+ * Defines the extract tuple elements type used by this module.
  * @template {unknown[]} 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 {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
  */
 
+/**
+ * Maps each tuple in `T` to a record from its `[0]` key to its `[I]` value.
+ * @template {unknown[]} 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 {TupleToTypeMap<ParsersAndGeneratorsByTypes, 1>} ParserByType */
+/** @typedef {TupleToTypeMap<ParsersAndGeneratorsByTypes, 2>} ParserOptionsByType */
+/** @typedef {TupleToTypeMap<ParsersAndGeneratorsByTypes, 3>} GeneratorByType */
+/** @typedef {TupleToTypeMap<ParsersAndGeneratorsByTypes, 4>} GeneratorOptionsByType */
+
 class NormalModuleFactory extends ModuleFactory {
 	/**
+	 * Creates an instance of NormalModuleFactory.
 	 * @param {object} param params
 	 * @param {string=} param.context context
 	 * @param {InputFileSystem} param.fs file system
@@ -369,7 +435,10 @@ class NormalModuleFactory extends ModuleFactory {
 			resolveForScheme: new HookMap(
 				() => new AsyncSeriesBailHook(["resourceData", "resolveData"])
 			),
-			/** @type {HookMap<AsyncSeriesBailHook<[ResourceDataWithData, ResolveData], true | void>>} */
+			/**
+			 * @type {HookMap<AsyncSeriesBailHook<[ResourceDataWithData, ResolveData], true | void>>}
+			 * @since 5.49.0
+			 */
 			resolveInScheme: new HookMap(
 				() => new AsyncSeriesBailHook(["resourceData", "resolveData"])
 			),
@@ -395,7 +464,10 @@ class NormalModuleFactory extends ModuleFactory {
 			generator: new HookMap(
 				() => new SyncHook(["generator", "generatorOptions"])
 			),
-			/** @type {HookMap<SyncBailHook<[CreateData, ResolveData], Module | void>>} */
+			/**
+			 * @type {HookMap<SyncBailHook<[CreateData, ResolveData], Module | void>>}
+			 * @since 5.81.0
+			 */
 			createModuleClass: new HookMap(
 				() => new SyncBailHook(["createData", "resolveData"])
 			)
@@ -423,6 +495,8 @@ class NormalModuleFactory extends ModuleFactory {
 		this.generatorCache = new Map();
 		/** @type {Set<Module>} */
 		this._restoredUnsafeCacheEntries = new Set();
+		/** @type {Map<string, LoaderResolveCacheEntry>} */
+		this._loaderResolveCache = new Map();
 
 		/** @type {(resource: string) => import("./util/identifier").ParsedResource} */
 		const cacheParseResource = parseResource.bindCache(
@@ -471,7 +545,9 @@ class NormalModuleFactory extends ModuleFactory {
 						// Ignored
 						if (result === false) return callback();
 
-						const createData = resolveData.createData;
+						const createData =
+							/** @type {CreateData} */
+							(resolveData.createData);
 
 						this.hooks.createModule.callAsync(
 							createData,
@@ -484,18 +560,12 @@ class NormalModuleFactory extends ModuleFactory {
 
 									// TODO webpack 6 make it required and move javascript/wasm/asset properties to own module
 									createdModule = this.hooks.createModuleClass
-										.for(
-											/** @type {ModuleSettings} */
-											(createData.settings).type
-										)
+										.for(createData.settings.type)
 										.call(createData, resolveData);
 
 									if (!createdModule) {
 										createdModule = /** @type {Module} */ (
-											new NormalModule(
-												/** @type {NormalModuleCreateData} */
-												(createData)
-											)
+											new NormalModule(createData)
 										);
 									}
 								}
@@ -868,6 +938,7 @@ class NormalModuleFactory extends ModuleFactory {
 				);
 
 				/**
+				 * Processes the provided string.
 				 * @param {string} context context
 				 */
 				const defaultResolve = (context) => {
@@ -895,7 +966,7 @@ class NormalModuleFactory extends ModuleFactory {
 						this.resolveResource(
 							contextInfo,
 							context,
-							unresolvedResource,
+							escapeHashInPathRequest(unresolvedResource),
 							normalResolver,
 							resolveContext,
 							(err, _resolvedResource, resolvedResourceResolveData) => {
@@ -972,6 +1043,7 @@ class NormalModuleFactory extends ModuleFactory {
 	}
 
 	/**
+	 * Processes the provided data.
 	 * @param {ModuleFactoryCreateData} data data object
 	 * @param {ModuleFactoryCallback} callback callback
 	 * @returns {void}
@@ -1080,6 +1152,7 @@ class NormalModuleFactory extends ModuleFactory {
 	}
 
 	/**
+	 * Processes the provided context info.
 	 * @param {ModuleFactoryCreateDataContextInfo} contextInfo context info
 	 * @param {string} context context
 	 * @param {string} unresolvedResource unresolved resource
@@ -1152,6 +1225,7 @@ ${hints.join("\n\n")}`;
 	}
 
 	/**
+	 * Resolve resource error hints.
 	 * @param {Error} error error
 	 * @param {ModuleFactoryCreateDataContextInfo} contextInfo context info
 	 * @param {string} context context
@@ -1277,6 +1351,7 @@ If changing the source code is not an option there is also a resolve options cal
 	}
 
 	/**
+	 * Resolves request array.
 	 * @param {ModuleFactoryCreateDataContextInfo} contextInfo context info
 	 * @param {string} context context
 	 * @param {LoaderItem[]} array array
@@ -1298,16 +1373,47 @@ If changing the source code is not an option there is also a resolve options cal
 		asyncLib.map(
 			array,
 			/**
+			 * Handles the callback logic for this hook.
 			 * @param {LoaderItem} item item
 			 * @param {Callback<LoaderItem>} callback callback
+			 * @returns {void}
 			 */
 			(item, callback) => {
+				// Loaders resolve identically for a given (context, request), so memoize
+				// the result and the resolve's dependencies to skip repeated resolves.
+				const cacheKey = `${context}\n${item.loader}`;
+				const cached = this._loaderResolveCache.get(cacheKey);
+				if (cached !== undefined) {
+					replayResolveDependencies(resolveContext, cached);
+					return callback(null, {
+						loader: cached.loader,
+						type: cached.type,
+						options:
+							item.options === undefined
+								? cached.query
+									? cached.query.slice(1)
+									: undefined
+								: item.options,
+						ident: item.options === undefined ? undefined : item.ident
+					});
+				}
+				// Capture this resolve's dependencies in dedicated sets so a future hit
+				// can replay them; also feed them back into the caller's resolveContext.
+				const captureContext = {
+					...resolveContext,
+					fileDependencies: new LazySet(),
+					contextDependencies: new LazySet(),
+					missingDependencies: new LazySet()
+				};
 				resolver.resolve(
 					contextInfo,
 					context,
 					item.loader,
-					resolveContext,
+					captureContext,
 					(err, result, resolveRequest) => {
+						// Merge the captured dependencies back so a failed or successful
+						// resolve records them for watch invalidation just like before.
+						replayResolveDependencies(resolveContext, captureContext);
 						if (
 							err &&
 							/^[^/]*$/.test(item.loader) &&
@@ -1349,6 +1455,16 @@ If changing the source code is not an option there is also a resolve options cal
 											/** @type {ResolveRequest} */
 											(resolveRequest).descriptionFileData.type
 										);
+
+						this._loaderResolveCache.set(cacheKey, {
+							loader: parsedResult.path,
+							query: parsedResult.query,
+							type,
+							fileDependencies: captureContext.fileDependencies,
+							contextDependencies: captureContext.contextDependencies,
+							missingDependencies: captureContext.missingDependencies
+						});
+
 						/** @type {LoaderItem} */
 						const resolved = {
 							loader: parsedResult.path,
@@ -1376,9 +1492,11 @@ If changing the source code is not an option there is also a resolve options cal
 	}
 
 	/**
-	 * @param {string} type type
+	 * Returns parser.
+	 * @template {string} T
+	 * @param {T} type type
 	 * @param {ParserOptions} parserOptions parser options
-	 * @returns {Parser} parser
+	 * @returns {ParserByType[T]} parser
 	 */
 	getParser(type, parserOptions = EMPTY_PARSER_OPTIONS) {
 		let cache = this.parserCache.get(type);
@@ -1395,13 +1513,15 @@ If changing the source code is not an option there is also a resolve options cal
 			cache.set(parserOptions, parser);
 		}
 
-		return parser;
+		return /** @type {ParserByType[T]} */ (parser);
 	}
 
 	/**
-	 * @param {string} type type
+	 * Creates a parser from the provided type.
+	 * @template {string} T
+	 * @param {T} type type
 	 * @param {ParserOptions} parserOptions parser options
-	 * @returns {Parser} parser
+	 * @returns {ParserByType[T]} parser
 	 */
 	createParser(type, parserOptions = {}) {
 		parserOptions = mergeGlobalOptions(
@@ -1414,13 +1534,15 @@ If changing the source code is not an option there is also a resolve options cal
 			throw new Error(`No parser registered for ${type}`);
 		}
 		this.hooks.parser.for(type).call(parser, parserOptions);
-		return parser;
+		return /** @type {ParserByType[T]} */ (parser);
 	}
 
 	/**
-	 * @param {string} type type of generator
+	 * Returns generator.
+	 * @template {string} T
+	 * @param {T} type type of generator
 	 * @param {GeneratorOptions} generatorOptions generator options
-	 * @returns {Generator} generator
+	 * @returns {GeneratorByType[T]} generator
 	 */
 	getGenerator(type, generatorOptions = EMPTY_GENERATOR_OPTIONS) {
 		let cache = this.generatorCache.get(type);
@@ -1437,13 +1559,15 @@ If changing the source code is not an option there is also a resolve options cal
 			cache.set(generatorOptions, generator);
 		}
 
-		return generator;
+		return /** @type {GeneratorByType[T]} */ (generator);
 	}
 
 	/**
-	 * @param {string} type type of generator
+	 * Creates a generator.
+	 * @template {string} T
+	 * @param {T} type type of generator
 	 * @param {GeneratorOptions} generatorOptions generator options
-	 * @returns {Generator} generator
+	 * @returns {GeneratorByType[T]} generator
 	 */
 	createGenerator(type, generatorOptions = {}) {
 		generatorOptions = mergeGlobalOptions(
@@ -1458,10 +1582,11 @@ If changing the source code is not an option there is also a resolve options cal
 			throw new Error(`No generator registered for ${type}`);
 		}
 		this.hooks.generator.for(type).call(generator, generatorOptions);
-		return generator;
+		return /** @type {GeneratorByType[T]} */ (generator);
 	}
 
 	/**
+	 * Returns the resolver.
 	 * @param {Parameters<ResolverFactory["get"]>[0]} type type of resolver
 	 * @param {Parameters<ResolverFactory["get"]>[1]=} resolveOptions options
 	 * @returns {ReturnType<ResolverFactory["get"]>} the resolver

package/lib/NormalModuleReplacementPlugin.js

@@ -22,12 +22,14 @@ class NormalModuleReplacementPlugin {
 	 * @param {string | ModuleReplacer} newResource the resource replacement
 	 */
 	constructor(resourceRegExp, newResource) {
+		/** @type {RegExp} */
 		this.resourceRegExp = resourceRegExp;
+		/** @type {string | ModuleReplacer} */
 		this.newResource = newResource;
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */

package/lib/NullFactory.js

@@ -12,6 +12,7 @@ const ModuleFactory = require("./ModuleFactory");
 
 class NullFactory extends ModuleFactory {
 	/**
+	 * Processes the provided data.
 	 * @param {ModuleFactoryCreateData} data data object
 	 * @param {ModuleFactoryCallback} callback callback
 	 * @returns {void}

package/lib/OptionsApply.js

@@ -11,6 +11,7 @@
 
 class OptionsApply {
 	/**
+	 * Returns options object.
 	 * @param {WebpackOptions} options options object
 	 * @param {Compiler} compiler compiler object
 	 * @param {WebpackOptionsInterception=} interception intercepted options

package/lib/Parser.js

@@ -12,6 +12,7 @@
 /** @typedef {Record<string, EXPECTED_ANY>} PreparsedAst */
 
 /**
+ * Defines the parser state base type used by this module.
  * @typedef {object} ParserStateBase
  * @property {string | Buffer} source
  * @property {NormalModule} current
@@ -25,13 +26,14 @@
 class Parser {
 	/* istanbul ignore next */
 	/**
+	 * Parses the provided source and updates the parser state.
 	 * @abstract
 	 * @param {string | Buffer | PreparsedAst} source the source to parse
 	 * @param {ParserState} state the parser state
 	 * @returns {ParserState} the parser state
 	 */
 	parse(source, state) {
-		const AbstractMethodError = require("./AbstractMethodError");
+		const AbstractMethodError = require("./errors/AbstractMethodError");
 
 		throw new AbstractMethodError();
 	}

package/lib/PlatformPlugin.js

@@ -16,6 +16,7 @@ const PLUGIN_NAME = "PlatformPlugin";
  */
 class PlatformPlugin {
 	/**
+	 * Creates an instance of PlatformPlugin.
 	 * @param {Partial<PlatformTargetProperties>} platform target properties
 	 */
 	constructor(platform) {
@@ -24,7 +25,7 @@ class PlatformPlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */

package/lib/PrefetchPlugin.js

@@ -13,12 +13,15 @@ const PLUGIN_NAME = "PrefetchPlugin";
 
 class PrefetchPlugin {
 	/**
+	 * Creates an instance of PrefetchPlugin.
 	 * @param {string} context context or request if context is not set
 	 * @param {string=} request request
 	 */
 	constructor(context, request) {
 		if (request) {
+			/** @type {string | null} */
 			this.context = context;
+			/** @type {string} */
 			this.request = request;
 		} else {
 			this.context = null;
@@ -27,7 +30,7 @@ class PrefetchPlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */