@depup/webpack 5.109.0-depup.0 → 5.110.1-depup.0

package/lib/FlagDependencyExportsPlugin.js

@@ -7,25 +7,27 @@
 
 const asyncLib = require("neo-async");
 const Queue = require("./util/Queue");
+const { compareModulesByIdentifier } = require("./util/comparators");
 const createHash = require("./util/createHash");
 
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
-/** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./Dependency").ExportSpec} ExportSpec */
-/** @typedef {import("./Dependency").ExportsSpec} ExportsSpec */
-/** @typedef {import("./ExportsInfo")} ExportsInfo */
-/** @typedef {import("./ExportsInfo").ExportInfoName} ExportInfoName */
-/** @typedef {import("./ExportsInfo").RestoreProvidedData} RestoreProvidedData */
-/** @typedef {import("../declarations/WebpackOptions").HashFunction} HashFunction */
-/** @typedef {import("./LazyBarrel")} LazyBarrelController */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./Module").BuildInfo} BuildInfo */
+/** @import Compiler from "./Compiler" */
+/** @import DependenciesBlock from "./DependenciesBlock" */
+/**
+ * @import Dependency, {
+ * 	ExportSpec,
+ * 	ExportsSpec,
+ * 	ExportInfoName
+ * } from "./Dependency"
+ */
+/** @import ExportsInfo, { RestoreProvidedData } from "./ExportsInfo" */
+/** @import { HashFunction } from "../declarations/WebpackOptions" */
+/** @import LazyBarrelController from "./LazyBarrel" */
+/** @import Module, { BuildInfo } from "./Module" */
 
 const PLUGIN_NAME = "FlagDependencyExportsPlugin";
 const PLUGIN_LOGGER_NAME = `webpack.${PLUGIN_NAME}`;
 
-/** @typedef {{ etag: string, data: RestoreProvidedData }} MemCacheEntry */
+/** @typedef {{ etag: string, data: InstanceType<RestoreProvidedData> }} MemCacheEntry */
 
 /**
  * @param {Module} module the module
@@ -70,6 +72,8 @@ class FlagDependencyExportsPlugin {
 
 					/** @type {Queue<Module>} */
 					const queue = new Queue();
+					/** @type {Set<Module>} */
+					const modulesToAnalyse = new Set();
 
 					// Step 1: Try to restore cached provided export info from cache
 					logger.time("restore cached provided exports");
@@ -97,8 +101,8 @@ class FlagDependencyExportsPlugin {
 								"string"
 							) {
 								statFlaggedUncached++;
-								// Enqueue uncacheable module for determining the exports
-								queue.enqueue(module);
+								// Determined below, in a stable order
+								modulesToAnalyse.add(module);
 								exportsInfo.setHasProvideInfo();
 								return callback();
 							}
@@ -133,8 +137,8 @@ class FlagDependencyExportsPlugin {
 										exportsInfo.restoreProvided(result);
 									} else {
 										statNotCached++;
-										// Without cached info enqueue module for determining the exports
-										queue.enqueue(module);
+										// Without cached info determine the exports below
+										modulesToAnalyse.add(module);
 										exportsInfo.setHasProvideInfo();
 									}
 									callback();
@@ -145,6 +149,59 @@ class FlagDependencyExportsPlugin {
 							logger.timeEnd("restore cached provided exports");
 							if (err) return callback(err);
 
+							// Seed the queue with targets before the modules that read
+							// them. Enqueueing at the two branches above ordered the work by
+							// how fast each cache lookup answered — one is synchronous, the
+							// other a `cache.get` callback — so the persistent cache decided
+							// it. A module analysed before the module it re-exports from
+							// reads exports that are not determined yet and over-estimates,
+							// and this loop can add exports info but never retract it, so
+							// the over-estimate survives the pass that corrects it. The
+							// roots are sorted so the walk is stable, and post-order visits
+							// each module after everything it points at.
+							/** @type {Set<Module>} */
+							const visited = new Set();
+							/** @type {Module[]} */
+							const stack = [];
+							/** @type {Set<Module>} */
+							const expanded = new Set();
+							for (const root of [...modulesToAnalyse].sort(
+								compareModulesByIdentifier
+							)) {
+								if (visited.has(root)) continue;
+								stack.push(root);
+								while (stack.length > 0) {
+									const current = stack[stack.length - 1];
+									if (expanded.has(current)) {
+										stack.pop();
+										if (!visited.has(current)) {
+											visited.add(current);
+											if (modulesToAnalyse.has(current)) {
+												queue.enqueue(current);
+											}
+										}
+										continue;
+									}
+									expanded.add(current);
+									for (const connection of moduleGraph.getOutgoingConnections(
+										current
+									)) {
+										const target = connection.module;
+										// A module restored from cache is already final, so
+										// nothing has to be ordered before it and the walk stops
+										// there — on an incremental build that is most of them.
+										if (
+											target !== undefined &&
+											target !== null &&
+											modulesToAnalyse.has(target) &&
+											!expanded.has(target)
+										) {
+											stack.push(target);
+										}
+									}
+								}
+							}
+
 							/** @type {Set<Module>} */
 							const modulesToStore = new Set();
 
@@ -489,7 +546,7 @@ class FlagDependencyExportsPlugin {
 				}
 			);
 
-			/** @type {WeakMap<Module, RestoreProvidedData>} */
+			/** @type {WeakMap<Module, InstanceType<RestoreProvidedData>>} */
 			const providedExportsCache = new WeakMap();
 			compilation.hooks.rebuildModule.tap(PLUGIN_NAME, (module) => {
 				providedExportsCache.set(
@@ -499,7 +556,7 @@ class FlagDependencyExportsPlugin {
 			});
 			compilation.hooks.finishRebuildingModule.tap(PLUGIN_NAME, (module) => {
 				moduleGraph.getExportsInfo(module).restoreProvided(
-					/** @type {RestoreProvidedData} */
+					/** @type {InstanceType<RestoreProvidedData>} */
 					(providedExportsCache.get(module))
 				);
 			});

package/lib/FlagDependencyUsagePlugin.js

@@ -11,15 +11,15 @@ const ModuleGraphConnection = require("./ModuleGraphConnection");
 const { STAGE_DEFAULT } = require("./OptimizationStages");
 const ArrayQueue = require("./util/ArrayQueue");
 const TupleQueue = require("./util/TupleQueue");
+const TupleSet = require("./util/TupleSet");
 const { getEntryRuntime, mergeRuntimeOwned } = require("./util/runtime");
 
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
-/** @typedef {import("./Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("./Dependency").ReferencedExports} ReferencedExports */
-/** @typedef {import("./ExportsInfo")} ExportsInfo */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+/** @import Compiler from "./Compiler" */
+/** @import DependenciesBlock from "./DependenciesBlock" */
+/** @import { ReferencedExport, ReferencedExports } from "./Dependency" */
+/** @import ExportsInfo from "./ExportsInfo" */
+/** @import Module from "./Module" */
+/** @import { RuntimeSpec } from "./util/runtime" */
 
 const {
 	NO_EXPORTS_REFERENCED,
@@ -30,6 +30,19 @@ const {
 const PLUGIN_NAME = "FlagDependencyUsagePlugin";
 const PLUGIN_LOGGER_NAME = `webpack.${PLUGIN_NAME}`;
 
+// Hoisted stateless predicates for setUsedConditionally on the innermost
+// used-export loop, so they aren't re-allocated per export.
+/**
+ * @param {import("./ExportsInfo").UsageStateType} used usage state
+ * @returns {boolean} whether unused
+ */
+const IS_UNUSED = (used) => used === UsageState.Unused;
+/**
+ * @param {import("./ExportsInfo").UsageStateType} used usage state
+ * @returns {boolean} whether not used
+ */
+const IS_NOT_USED = (used) => used !== UsageState.Used;
+
 class FlagDependencyUsagePlugin {
 	/**
 	 * Creates an instance of FlagDependencyUsagePlugin.
@@ -67,20 +80,17 @@ class FlagDependencyUsagePlugin {
 					/** @type {TupleQueue<Module, RuntimeSpec>} */
 					const queue = new TupleQueue();
 
+					/** @type {TupleSet<Module, RuntimeSpec> | undefined} */
+					let walkedSideEffectFreeModules;
+
 					/**
 					 * Process referenced module.
 					 * @param {Module} module module to process
 					 * @param {ReferencedExports} usedExports list of used exports
 					 * @param {RuntimeSpec} runtime part of which runtime
-					 * @param {boolean} forceSideEffects always apply side effects
 					 * @returns {void}
 					 */
-					const processReferencedModule = (
-						module,
-						usedExports,
-						runtime,
-						forceSideEffects
-					) => {
+					const processReferencedModule = (module, usedExports, runtime) => {
 						const exportsInfo = moduleGraph.getExportsInfo(module);
 						if (usedExports === EXPORTS_OBJECT_REFERENCED_MANGLEABLE) {
 							// The whole namespace object escapes via a reference that codegen
@@ -162,7 +172,7 @@ class FlagDependencyUsagePlugin {
 											if (nestedInfo) {
 												if (
 													exportInfo.setUsedConditionally(
-														(used) => used === UsageState.Unused,
+														IS_UNUSED,
 														UsageState.OnlyPropertiesUsed,
 														runtime
 													)
@@ -181,7 +191,7 @@ class FlagDependencyUsagePlugin {
 										}
 										if (
 											exportInfo.setUsedConditionally(
-												(v) => v !== UsageState.Used,
+												IS_NOT_USED,
 												UsageState.Used,
 												runtime
 											)
@@ -198,20 +208,22 @@ class FlagDependencyUsagePlugin {
 									}
 								}
 							}
-						} else {
-							// for a module without side effects we stop tracking usage here when no export is used
-							// This module won't be evaluated in this case
-							// TODO webpack 6 remove this check
-							if (
-								!forceSideEffects &&
-								module.factoryMeta !== undefined &&
-								module.factoryMeta.sideEffectFree
-							) {
-								return;
+						} else if (
+							module.factoryMeta !== undefined &&
+							module.factoryMeta.sideEffectFree
+						) {
+							// Nothing is used and the module has no side effects, so it is
+							// not used for them either. An active connection still evaluates
+							// it, so keep walking it to count the references it makes itself.
+							if (walkedSideEffectFreeModules === undefined) {
+								walkedSideEffectFreeModules = new TupleSet();
 							}
-							if (exportsInfo.setUsedForSideEffectsOnly(runtime)) {
+							if (!walkedSideEffectFreeModules.has(module, runtime)) {
+								walkedSideEffectFreeModules.add(module, runtime);
 								queue.enqueue(module, runtime);
 							}
+						} else if (exportsInfo.setUsedForSideEffectsOnly(runtime)) {
+							queue.enqueue(module, runtime);
 						}
 					};
 
@@ -219,18 +231,18 @@ class FlagDependencyUsagePlugin {
 					 * Processes the provided module.
 					 * @param {DependenciesBlock} module the module
 					 * @param {RuntimeSpec} runtime part of which runtime
-					 * @param {boolean} forceSideEffects always apply side effects
 					 * @returns {void}
 					 */
-					const processModule = (module, runtime, forceSideEffects) => {
+					const processModule = (module, runtime) => {
 						/** @typedef {Map<string, string[] | ReferencedExport>} ExportMaps */
 						/** @type {Map<Module, ReferencedExports | ExportMaps>} */
 						const map = new Map();
 						// Modules whose whole namespace object escapes in a mangleable way.
 						// Tracked separately so specific member references are still merged
 						// (and marked used) instead of being dropped by the escape marker.
-						/** @type {Set<Module>} */
-						const mangleableEscapeModules = new Set();
+						// Lazily allocated — usually empty.
+						/** @type {Set<Module> | undefined} */
+						let mangleableEscapeModules;
 
 						/** @type {ArrayQueue<DependenciesBlock>} */
 						const queue = new ArrayQueue();
@@ -244,8 +256,7 @@ class FlagDependencyUsagePlugin {
 										b,
 										this.global
 											? undefined
-											: b.groupOptions.entryOptions.runtime || undefined,
-										true
+											: b.groupOptions.entryOptions.runtime || undefined
 									);
 								} else {
 									queue.enqueue(b);
@@ -260,7 +271,7 @@ class FlagDependencyUsagePlugin {
 								if (activeState === false) continue;
 								const { module } = connection;
 								if (activeState === ModuleGraphConnection.TRANSITIVE_ONLY) {
-									processModule(module, runtime, false);
+									processModule(module, runtime);
 									continue;
 								}
 								const oldReferencedExports = map.get(module);
@@ -273,7 +284,9 @@ class FlagDependencyUsagePlugin {
 								// conservative result and always wins.
 								if (referencedExports === EXPORTS_OBJECT_REFERENCED) {
 									map.set(module, EXPORTS_OBJECT_REFERENCED);
-									mangleableEscapeModules.delete(module);
+									if (mangleableEscapeModules) {
+										mangleableEscapeModules.delete(module);
+									}
 									continue;
 								}
 								// A mangleable whole-object escape keeps the module's exports
@@ -284,6 +297,9 @@ class FlagDependencyUsagePlugin {
 								if (
 									referencedExports === EXPORTS_OBJECT_REFERENCED_MANGLEABLE
 								) {
+									if (mangleableEscapeModules === undefined) {
+										mangleableEscapeModules = new Set();
+									}
 									mangleableEscapeModules.add(module);
 									continue;
 								}
@@ -343,28 +359,23 @@ class FlagDependencyUsagePlugin {
 
 						for (const [module, referencedExports] of map) {
 							if (Array.isArray(referencedExports)) {
-								processReferencedModule(
-									module,
-									referencedExports,
-									runtime,
-									forceSideEffects
-								);
+								processReferencedModule(module, referencedExports, runtime);
 							} else {
 								processReferencedModule(
 									module,
 									[...referencedExports.values()],
-									runtime,
-									forceSideEffects
+									runtime
 								);
 							}
 						}
-						for (const module of mangleableEscapeModules) {
-							processReferencedModule(
-								module,
-								EXPORTS_OBJECT_REFERENCED_MANGLEABLE,
-								runtime,
-								forceSideEffects
-							);
+						if (mangleableEscapeModules) {
+							for (const module of mangleableEscapeModules) {
+								processReferencedModule(
+									module,
+									EXPORTS_OBJECT_REFERENCED_MANGLEABLE,
+									runtime
+								);
+							}
 						}
 					};
 
@@ -386,12 +397,7 @@ class FlagDependencyUsagePlugin {
 					const processEntryDependency = (dep, runtime) => {
 						const module = moduleGraph.getModule(dep);
 						if (module) {
-							processReferencedModule(
-								module,
-								NO_EXPORTS_REFERENCED,
-								runtime,
-								true
-							);
+							processReferencedModule(module, NO_EXPORTS_REFERENCED, runtime);
 						}
 					};
 					/** @type {RuntimeSpec} */
@@ -422,7 +428,7 @@ class FlagDependencyUsagePlugin {
 						const [module, runtime] = /** @type {[Module, RuntimeSpec]} */ (
 							queue.dequeue()
 						);
-						processModule(module, runtime, false);
+						processModule(module, runtime);
 					}
 					logger.timeEnd("trace exports usage in graph");
 				}

package/lib/FlagEntryExportAsUsedPlugin.js

@@ -7,7 +7,7 @@
 
 const { getEntryRuntime } = require("./util/runtime");
 
-/** @typedef {import("./Compiler")} Compiler */
+/** @import Compiler from "./Compiler" */
 
 const PLUGIN_NAME = "FlagEntryExportAsUsedPlugin";
 

package/lib/Generator.js

@@ -6,22 +6,27 @@
 "use strict";
 
 const { JAVASCRIPT_TYPE } = require("./ModuleSourceTypeConstants");
+const memoize = require("./util/memoize");
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */
-/** @typedef {import("./ConcatenationScope")} ConcatenationScope */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("./Module").CodeGenerationResultData} CodeGenerationResultData */
-/** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
-/** @typedef {import("./Module").RuntimeRequirements} RuntimeRequirements */
-/** @typedef {import("./Module").SourceType} SourceType */
-/** @typedef {import("./Module").SourceTypes} SourceTypes */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./NormalModule")} NormalModule */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./util/Hash")} Hash */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+/** @import { Source } from "webpack-sources" */
+/** @import ChunkGraph from "./ChunkGraph" */
+/** @import CodeGenerationResults from "./CodeGenerationResults" */
+/** @import ConcatenationScope from "./ConcatenationScope" */
+/** @import DependencyTemplates from "./DependencyTemplates" */
+/**
+ * @import {
+ * 	CodeGenerationResultData,
+ * 	ConcatenationBailoutReasonContext,
+ * 	RuntimeRequirements,
+ * 	SourceType,
+ * 	SourceTypes
+ * } from "./Module"
+ */
+/** @import ModuleGraph from "./ModuleGraph" */
+/** @import NormalModule from "./NormalModule" */
+/** @import RuntimeTemplate from "./RuntimeTemplate" */
+/** @import Hash from "./util/Hash" */
+/** @import { RuntimeSpec } from "./util/runtime" */
 
 /**
  * Defines the generate context type used by this module.
@@ -56,6 +61,8 @@ const { JAVASCRIPT_TYPE } = require("./ModuleSourceTypeConstants");
  * @property {RuntimeTemplate=} runtimeTemplate
  */
 
+const getModuleParseError = memoize(() => require("./errors/ModuleParseError"));
+
 class Generator {
 	/**
 	 * Returns generator by type.
@@ -66,6 +73,20 @@ class Generator {
 		return new ByTypeGenerator(map);
 	}
 
+	/**
+	 * Returns the statement a module that failed to build throws when executed.
+	 * @param {Error} error the build error
+	 * @param {string=} parseErrorConstructor constructor for a rejected source, defaults to `SyntaxError` (WebAssembly rejects with `WebAssembly.CompileError` instead)
+	 * @returns {string} javascript statement
+	 */
+	static throwBuildErrorCode(error, parseErrorConstructor = "SyntaxError") {
+		// A source the parser rejected throws what a native load of it would.
+		const name =
+			error instanceof getModuleParseError() ? parseErrorConstructor : "Error";
+
+		return `throw new ${name}(${JSON.stringify(error.message)});`;
+	}
+
 	/* istanbul ignore next */
 	/**
 	 * Returns the source types available for this module.

package/lib/HotModuleReplacementPlugin.js

@@ -5,7 +5,6 @@
 
 "use strict";
 
-const { SyncBailHook } = require("tapable");
 const { RawSource } = require("webpack-sources");
 const ChunkGraph = require("./ChunkGraph");
 const Compilation = require("./Compilation");
@@ -27,7 +26,7 @@ const ModuleHotAcceptDependency = require("./dependencies/ModuleHotAcceptDepende
 const ModuleHotDeclineDependency = require("./dependencies/ModuleHotDeclineDependency");
 const WebpackError = require("./errors/WebpackError");
 const HotModuleReplacementRuntimeModule = require("./hmr/HotModuleReplacementRuntimeModule");
-const JavascriptParser = require("./javascript/JavascriptParser");
+const getParserHooks = require("./hmr/parserHooks");
 const {
 	evaluateToIdentifier
 } = require("./javascript/JavascriptParserHelpers");
@@ -44,34 +43,22 @@ const {
 	subtractRuntime
 } = require("./util/runtime");
 
-/** @typedef {import("estree").CallExpression} CallExpression */
-/** @typedef {import("estree").Expression} Expression */
-/** @typedef {import("estree").SpreadElement} SpreadElement */
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./Chunk").ChunkId} ChunkId */
-/** @typedef {import("./ChunkGraph").ModuleId} ModuleId */
-/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("./Compilation").Records} Records */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./Module").BuildInfo} BuildInfo */
-/** @typedef {import("./css/CssModule").CssModuleBuildMeta} CssModuleBuildMeta */
-/** @typedef {import("./RuntimeModule")} RuntimeModule */
-/** @typedef {import("./javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
-/** @typedef {import("./javascript/JavascriptParserHelpers").Range} Range */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+/** @import { CallExpression, Expression } from "estree" */
+/** @import Chunk, { ChunkId } from "./Chunk" */
+/** @import { ModuleId } from "./ChunkGraph" */
+/** @import { AssetInfo } from "./Compilation" */
+/** @import Compiler, { Records } from "./Compiler" */
+/** @import CodeGenerationResults from "./CodeGenerationResults" */
+/** @import Module, { BuildInfo } from "./Module" */
+/** @import { CssModuleBuildMeta } from "./css/CssModule" */
+/** @import { HMRJavascriptParserHooks } from "./hmr/parserHooks" */
+/** @import RuntimeModule from "./RuntimeModule" */
+/** @import BasicEvaluatedExpression from "./javascript/BasicEvaluatedExpression" */
+/** @import JavascriptParser, { Range } from "./javascript/JavascriptParser" */
+/** @import { RuntimeSpec } from "./util/runtime" */
 
 /** @typedef {string[]} Requests */
 
-/**
- * Defines the hmr javascript parser hooks type used by this module.
- * @typedef {object} HMRJavascriptParserHooks
- * @property {SyncBailHook<[Expression | SpreadElement, Requests], void>} hotAcceptCallback
- * @property {SyncBailHook<[CallExpression, Requests], void>} hotAcceptWithoutCallback
- */
-
 /** @typedef {number} HotIndex */
 /** @typedef {Record<string, string>} FullHashChunkModuleHashes */
 /** @typedef {Record<string, string>} ChunkModuleHashes */
@@ -85,9 +72,6 @@ const {
 /** @typedef {{ updatedChunkIds: ChunkIds, removedChunkIds: ChunkIds, removedModules: ModuleSet, forceLoadChunkIds: ChunkIds, filename: string, assetInfo: AssetInfo }} HotUpdateMainContentByRuntimeItem */
 /** @typedef {Map<string, HotUpdateMainContentByRuntimeItem>} HotUpdateMainContentByRuntime */
 
-/** @type {WeakMap<JavascriptParser, HMRJavascriptParserHooks>} */
-const parserHooksMap = new WeakMap();
-
 const PLUGIN_NAME = "HotModuleReplacementPlugin";
 
 class HotModuleReplacementPlugin {
@@ -97,20 +81,7 @@ class HotModuleReplacementPlugin {
 	 * @returns {HMRJavascriptParserHooks} the attached hooks
 	 */
 	static getParserHooks(parser) {
-		if (!(parser instanceof JavascriptParser)) {
-			throw new TypeError(
-				"The 'parser' argument must be an instance of JavascriptParser"
-			);
-		}
-		let hooks = parserHooksMap.get(parser);
-		if (hooks === undefined) {
-			hooks = {
-				hotAcceptCallback: new SyncBailHook(["expression", "requests"]),
-				hotAcceptWithoutCallback: new SyncBailHook(["expression", "requests"])
-			};
-			parserHooksMap.set(parser, hooks);
-		}
-		return hooks;
+		return getParserHooks(parser);
 	}
 
 	/**
@@ -132,6 +103,7 @@ class HotModuleReplacementPlugin {
 		 * @returns {(expr: CallExpression) => boolean | undefined} callback
 		 */
 		const createAcceptHandler = (parser, ParamDependency) => {
+			// through the static method: replacing it stays a way to intercept
 			const { hotAcceptCallback, hotAcceptWithoutCallback } =
 				HotModuleReplacementPlugin.getParserHooks(parser);
 

package/lib/IgnorePlugin.js

@@ -8,10 +8,14 @@
 const RawModule = require("./RawModule");
 const EntryDependency = require("./dependencies/EntryDependency");
 
-/** @typedef {import("../declarations/plugins/IgnorePlugin").IgnorePluginOptions} IgnorePluginOptions */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./NormalModuleFactory").ResolveData} ResolveData */
-/** @typedef {import("./ContextModuleFactory").BeforeContextResolveData} BeforeContextResolveData */
+/**
+ * @import {
+ * 	IgnorePluginOptions
+ * } from "../declarations/plugins/IgnorePlugin"
+ */
+/** @import Compiler from "./Compiler" */
+/** @import { ResolveData } from "./NormalModuleFactory" */
+/** @import { BeforeContextResolveData } from "./ContextModuleFactory" */
 
 /** @typedef {(resource: string, context: string) => boolean} CheckResourceFn */
 

package/lib/IgnoreWarningsPlugin.js

@@ -5,8 +5,8 @@
 
 "use strict";
 
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Compilation")} Compilation */
+/** @import Compiler from "./Compiler" */
+/** @import Compilation from "./Compilation" */
 
 /** @typedef {(warning: Error, compilation: Compilation) => boolean} IgnoreFn */