webpack 5.97.1 → 5.104.1

package/lib/HotModuleReplacementPlugin.js

@@ -10,9 +10,16 @@ const { RawSource } = require("webpack-sources");
 const ChunkGraph = require("./ChunkGraph");
 const Compilation = require("./Compilation");
 const HotUpdateChunk = require("./HotUpdateChunk");
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+	JAVASCRIPT_MODULE_TYPE_ESM,
+	WEBPACK_MODULE_TYPE_RUNTIME
+} = require("./ModuleTypeConstants");
 const NormalModule = require("./NormalModule");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const WebpackError = require("./WebpackError");
+const { chunkHasCss } = require("./css/CssModulesPlugin");
 const ConstDependency = require("./dependencies/ConstDependency");
 const ImportMetaHotAcceptDependency = require("./dependencies/ImportMetaHotAcceptDependency");
 const ImportMetaHotDeclineDependency = require("./dependencies/ImportMetaHotDeclineDependency");
@@ -27,30 +34,24 @@ const { find, isSubset } = require("./util/SetHelpers");
 const TupleSet = require("./util/TupleSet");
 const { compareModulesById } = require("./util/comparators");
 const {
+	forEachRuntime,
 	getRuntimeKey,
+	intersectRuntime,
 	keyToRuntime,
-	forEachRuntime,
 	mergeRuntimeOwned,
-	subtractRuntime,
-	intersectRuntime
+	subtractRuntime
 } = require("./util/runtime");
 
-const {
-	JAVASCRIPT_MODULE_TYPE_AUTO,
-	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
-	JAVASCRIPT_MODULE_TYPE_ESM,
-	WEBPACK_MODULE_TYPE_RUNTIME
-} = require("./ModuleTypeConstants");
-
 /** @typedef {import("estree").CallExpression} CallExpression */
 /** @typedef {import("estree").Expression} Expression */
 /** @typedef {import("estree").SpreadElement} SpreadElement */
-/** @typedef {import("../declarations/WebpackOptions").OutputNormalized} OutputNormalized */
 /** @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 */
@@ -59,12 +60,21 @@ const {
 /** @typedef {import("./javascript/JavascriptParserHelpers").Range} Range */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
+/** @typedef {string[]} Requests */
+
 /**
  * @typedef {object} HMRJavascriptParserHooks
- * @property {SyncBailHook<[Expression | SpreadElement, string[]], void>} hotAcceptCallback
- * @property {SyncBailHook<[CallExpression, string[]], void>} hotAcceptWithoutCallback
+ * @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 */
+/** @typedef {Record<ChunkId, string>} ChunkHashes */
+/** @typedef {Record<ChunkId, string>} ChunkRuntime */
+/** @typedef {Record<ChunkId, ModuleId[]>} ChunkModuleIds */
+
 /** @typedef {{ updatedChunkIds: Set<ChunkId>, removedChunkIds: Set<ChunkId>, removedModules: Set<Module>, filename: string, assetInfo: AssetInfo }} HotUpdateMainContentByRuntimeItem */
 /** @typedef {Map<string, HotUpdateMainContentByRuntimeItem>} HotUpdateMainContentByRuntime */
 
@@ -95,13 +105,6 @@ class HotModuleReplacementPlugin {
 		return hooks;
 	}
 
-	/**
-	 * @param {object=} options options
-	 */
-	constructor(options) {
-		this.options = options || {};
-	}
-
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
@@ -109,8 +112,9 @@ class HotModuleReplacementPlugin {
 	 */
 	apply(compiler) {
 		const { _backCompat: backCompat } = compiler;
-		if (compiler.options.output.strictModuleErrorHandling === undefined)
+		if (compiler.options.output.strictModuleErrorHandling === undefined) {
 			compiler.options.output.strictModuleErrorHandling = true;
+		}
 		const runtimeRequirements = [RuntimeGlobals.module];
 
 		/**
@@ -122,7 +126,7 @@ class HotModuleReplacementPlugin {
 			const { hotAcceptCallback, hotAcceptWithoutCallback } =
 				HotModuleReplacementPlugin.getParserHooks(parser);
 
-			return expr => {
+			return (expr) => {
 				const module = parser.state.module;
 				const dep = new ConstDependency(
 					`${module.moduleArgument}.hot.accept`,
@@ -144,9 +148,9 @@ class HotModuleReplacementPlugin {
 					} else if (arg.isArray()) {
 						params =
 							/** @type {BasicEvaluatedExpression[]} */
-							(arg.items).filter(param => param.isString());
+							(arg.items).filter((param) => param.isString());
 					}
-					/** @type {string[]} */
+					/** @type {Requests} */
 					const requests = [];
 					if (params.length > 0) {
 						for (const [idx, param] of params.entries()) {
@@ -184,7 +188,7 @@ class HotModuleReplacementPlugin {
 		 * @param {typeof ModuleHotDeclineDependency} ParamDependency dependency
 		 * @returns {(expr: CallExpression) => boolean | undefined} callback
 		 */
-		const createDeclineHandler = (parser, ParamDependency) => expr => {
+		const createDeclineHandler = (parser, ParamDependency) => (expr) => {
 			const module = parser.state.module;
 			const dep = new ConstDependency(
 				`${module.moduleArgument}.hot.decline`,
@@ -204,7 +208,7 @@ class HotModuleReplacementPlugin {
 				} else if (arg.isArray()) {
 					params =
 						/** @type {BasicEvaluatedExpression[]} */
-						(arg.items).filter(param => param.isString());
+						(arg.items).filter((param) => param.isString());
 				}
 				for (const [idx, param] of params.entries()) {
 					const dep = new ParamDependency(
@@ -224,7 +228,7 @@ class HotModuleReplacementPlugin {
 		 * @param {JavascriptParser} parser the parser
 		 * @returns {(expr: Expression) => boolean | undefined} callback
 		 */
-		const createHMRExpressionHandler = parser => expr => {
+		const createHMRExpressionHandler = (parser) => (expr) => {
 			const module = parser.state.module;
 			const dep = new ConstDependency(
 				`${module.moduleArgument}.hot`,
@@ -242,13 +246,13 @@ class HotModuleReplacementPlugin {
 		 * @param {JavascriptParser} parser the parser
 		 * @returns {void}
 		 */
-		const applyModuleHot = parser => {
+		const applyModuleHot = (parser) => {
 			parser.hooks.evaluateIdentifier.for("module.hot").tap(
 				{
 					name: PLUGIN_NAME,
 					before: "NodeStuffPlugin"
 				},
-				expr =>
+				(expr) =>
 					evaluateToIdentifier(
 						"module.hot",
 						"module",
@@ -277,10 +281,10 @@ class HotModuleReplacementPlugin {
 		 * @param {JavascriptParser} parser the parser
 		 * @returns {void}
 		 */
-		const applyImportMetaHot = parser => {
+		const applyImportMetaHot = (parser) => {
 			parser.hooks.evaluateIdentifier
 				.for("import.meta.webpackHot")
-				.tap(PLUGIN_NAME, expr =>
+				.tap(PLUGIN_NAME, (expr) =>
 					evaluateToIdentifier(
 						"import.meta.webpackHot",
 						"import.meta",
@@ -350,10 +354,11 @@ class HotModuleReplacementPlugin {
 				);
 				// #endregion
 
+				/** @type {HotIndex} */
 				let hotIndex = 0;
-				/** @type {Record<string, string>} */
+				/** @type {FullHashChunkModuleHashes} */
 				const fullHashChunkModuleHashes = {};
-				/** @type {Record<string, string>} */
+				/** @type {ChunkModuleHashes} */
 				const chunkModuleHashes = {};
 
 				compilation.hooks.record.tap(PLUGIN_NAME, (compilation, records) => {
@@ -367,43 +372,42 @@ class HotModuleReplacementPlugin {
 					records.chunkRuntime = {};
 					for (const chunk of compilation.chunks) {
 						const chunkId = /** @type {ChunkId} */ (chunk.id);
-						records.chunkHashes[chunkId] = chunk.hash;
+						records.chunkHashes[chunkId] = /** @type {string} */ (chunk.hash);
 						records.chunkRuntime[chunkId] = getRuntimeKey(chunk.runtime);
 					}
 					records.chunkModuleIds = {};
 					for (const chunk of compilation.chunks) {
-						records.chunkModuleIds[/** @type {ChunkId} */ (chunk.id)] =
-							Array.from(
-								chunkGraph.getOrderedChunkModulesIterable(
-									chunk,
-									compareModulesById(chunkGraph)
-								),
-								m => chunkGraph.getModuleId(m)
-							);
+						const chunkId = /** @type {ChunkId} */ (chunk.id);
+
+						records.chunkModuleIds[chunkId] = Array.from(
+							chunkGraph.getOrderedChunkModulesIterable(
+								chunk,
+								compareModulesById(chunkGraph)
+							),
+							(m) => /** @type {ModuleId} */ (chunkGraph.getModuleId(m))
+						);
 					}
 				});
-				/** @type {TupleSet<[Module, Chunk]>} */
+				/** @type {TupleSet<Module, Chunk>} */
 				const updatedModules = new TupleSet();
-				/** @type {TupleSet<[Module, Chunk]>} */
+				/** @type {TupleSet<Module, Chunk>} */
 				const fullHashModules = new TupleSet();
-				/** @type {TupleSet<[Module, RuntimeSpec]>} */
+				/** @type {TupleSet<Module, RuntimeSpec>} */
 				const nonCodeGeneratedModules = new TupleSet();
-				compilation.hooks.fullHash.tap(PLUGIN_NAME, hash => {
+				compilation.hooks.fullHash.tap(PLUGIN_NAME, (hash) => {
 					const chunkGraph = compilation.chunkGraph;
-					const records = compilation.records;
+					const records = /** @type {Records} */ (compilation.records);
 					for (const chunk of compilation.chunks) {
 						/**
 						 * @param {Module} module module
 						 * @returns {string} module hash
 						 */
-						const getModuleHash = module => {
-							if (
-								compilation.codeGenerationResults.has(module, chunk.runtime)
-							) {
-								return compilation.codeGenerationResults.getHash(
-									module,
-									chunk.runtime
-								);
+						const getModuleHash = (module) => {
+							const codeGenerationResults =
+								/** @type {CodeGenerationResults} */
+								(compilation.codeGenerationResults);
+							if (codeGenerationResults.has(module, chunk.runtime)) {
+								return codeGenerationResults.getHash(module, chunk.runtime);
 							}
 							nonCodeGeneratedModules.add(module, chunk.runtime);
 							return chunkGraph.getModuleHash(module, chunk.runtime);
@@ -424,10 +428,14 @@ class HotModuleReplacementPlugin {
 										const hash = getModuleHash(module);
 										if (
 											fullHashModulesInThisChunk.has(
-												/** @type {RuntimeModule} */ (module)
+												/** @type {RuntimeModule} */
+												(module)
 											)
 										) {
-											if (records.fullHashChunkModuleHashes[key] !== hash) {
+											if (
+												/** @type {FullHashChunkModuleHashes} */
+												(records.fullHashChunkModuleHashes)[key] !== hash
+											) {
 												updatedModules.add(module, chunk);
 											}
 											fullHashChunkModuleHashes[key] = hash;
@@ -484,7 +492,7 @@ class HotModuleReplacementPlugin {
 					},
 					() => {
 						const chunkGraph = compilation.chunkGraph;
-						const records = compilation.records;
+						const records = /** @type {Records} */ (compilation.records);
 						if (records.hash === compilation.hash) return;
 						if (
 							!records.chunkModuleHashes ||
@@ -493,14 +501,14 @@ class HotModuleReplacementPlugin {
 						) {
 							return;
 						}
+						const codeGenerationResults =
+							/** @type {CodeGenerationResults} */
+							(compilation.codeGenerationResults);
 						for (const [module, chunk] of fullHashModules) {
 							const key = `${chunk.id}|${module.identifier()}`;
 							const hash = nonCodeGeneratedModules.has(module, chunk.runtime)
 								? chunkGraph.getModuleHash(module, chunk.runtime)
-								: compilation.codeGenerationResults.getHash(
-										module,
-										chunk.runtime
-									);
+								: codeGenerationResults.getHash(module, chunk.runtime);
 							if (records.chunkModuleHashes[key] !== hash) {
 								updatedModules.add(module, chunk);
 							}
@@ -510,15 +518,17 @@ class HotModuleReplacementPlugin {
 						/** @type {HotUpdateMainContentByRuntime} */
 						const hotUpdateMainContentByRuntime = new Map();
 						let allOldRuntime;
-						for (const key of Object.keys(records.chunkRuntime)) {
-							const runtime = keyToRuntime(records.chunkRuntime[key]);
+						const chunkRuntime =
+							/** @type {ChunkRuntime} */
+							(records.chunkRuntime);
+						for (const key of Object.keys(chunkRuntime)) {
+							const runtime = keyToRuntime(chunkRuntime[key]);
 							allOldRuntime = mergeRuntimeOwned(allOldRuntime, runtime);
 						}
-						forEachRuntime(allOldRuntime, runtime => {
+						forEachRuntime(allOldRuntime, (runtime) => {
 							const { path: filename, info: assetInfo } =
 								compilation.getPathWithInfo(
-									/** @type {NonNullable<OutputNormalized["hotUpdateMainFilename"]>} */
-									(compilation.outputOptions.hotUpdateMainFilename),
+									compilation.outputOptions.hotUpdateMainFilename,
 									{
 										hash: records.hash,
 										runtime
@@ -538,7 +548,7 @@ class HotModuleReplacementPlugin {
 						if (hotUpdateMainContentByRuntime.size === 0) return;
 
 						// Create a list of all active modules to verify which modules are removed completely
-						/** @type {Map<number|string, Module>} */
+						/** @type {Map<ModuleId, Module>} */
 						const allModules = new Map();
 						for (const module of compilation.modules) {
 							const id =
@@ -548,11 +558,14 @@ class HotModuleReplacementPlugin {
 						}
 
 						// List of completely removed modules
-						/** @type {Set<string | number>} */
+						/** @type {Set<ModuleId>} */
 						const completelyRemovedModules = new Set();
 
 						for (const key of Object.keys(records.chunkHashes)) {
-							const oldRuntime = keyToRuntime(records.chunkRuntime[key]);
+							const oldRuntime = keyToRuntime(
+								/** @type {ChunkRuntime} */
+								(records.chunkRuntime)[key]
+							);
 							/** @type {Module[]} */
 							const remainingModules = [];
 							// Check which modules are removed
@@ -575,7 +588,7 @@ class HotModuleReplacementPlugin {
 							let removedFromRuntime;
 							const currentChunk = find(
 								compilation.chunks,
-								chunk => `${chunk.id}` === key
+								(chunk) => `${chunk.id}` === key
 							);
 							if (currentChunk) {
 								chunkId = currentChunk.id;
@@ -586,22 +599,22 @@ class HotModuleReplacementPlugin {
 								if (newRuntime === undefined) continue;
 								newModules = chunkGraph
 									.getChunkModules(currentChunk)
-									.filter(module => updatedModules.has(module, currentChunk));
-								newRuntimeModules = Array.from(
-									chunkGraph.getChunkRuntimeModulesIterable(currentChunk)
-								).filter(module => updatedModules.has(module, currentChunk));
+									.filter((module) => updatedModules.has(module, currentChunk));
+								newRuntimeModules = [
+									...chunkGraph.getChunkRuntimeModulesIterable(currentChunk)
+								].filter((module) => updatedModules.has(module, currentChunk));
 								const fullHashModules =
 									chunkGraph.getChunkFullHashModulesIterable(currentChunk);
 								newFullHashModules =
 									fullHashModules &&
-									Array.from(fullHashModules).filter(module =>
+									[...fullHashModules].filter((module) =>
 										updatedModules.has(module, currentChunk)
 									);
 								const dependentHashModules =
 									chunkGraph.getChunkDependentHashModulesIterable(currentChunk);
 								newDependentHashModules =
 									dependentHashModules &&
-									Array.from(dependentHashModules).filter(module =>
+									[...dependentHashModules].filter((module) =>
 										updatedModules.has(module, currentChunk)
 									);
 								removedFromRuntime = subtractRuntime(oldRuntime, newRuntime);
@@ -613,7 +626,7 @@ class HotModuleReplacementPlugin {
 							}
 							if (removedFromRuntime) {
 								// chunk was removed from some runtimes
-								forEachRuntime(removedFromRuntime, runtime => {
+								forEachRuntime(removedFromRuntime, (runtime) => {
 									const item =
 										/** @type {HotUpdateMainContentByRuntimeItem} */
 										(
@@ -633,10 +646,7 @@ class HotModuleReplacementPlugin {
 										// Module is still in the same runtime combination
 										const hash = nonCodeGeneratedModules.has(module, newRuntime)
 											? chunkGraph.getModuleHash(module, newRuntime)
-											: compilation.codeGenerationResults.getHash(
-													module,
-													newRuntime
-												);
+											: codeGenerationResults.getHash(module, newRuntime);
 										if (hash !== oldHash) {
 											if (module.type === WEBPACK_MODULE_TYPE_RUNTIME) {
 												newRuntimeModules = newRuntimeModules || [];
@@ -652,7 +662,7 @@ class HotModuleReplacementPlugin {
 										// module is no longer in this runtime combination
 										// We (incorrectly) assume that it's not in an overlapping runtime combination
 										// and dispose it from the main runtimes the chunk was removed from
-										forEachRuntime(removedFromRuntime, runtime => {
+										forEachRuntime(removedFromRuntime, (runtime) => {
 											// If the module is still used in this runtime, do not dispose it
 											// This could create a bad runtime state where the module is still loaded,
 											// but no chunk which contains it. This means we don't receive further HMR updates
@@ -664,8 +674,9 @@ class HotModuleReplacementPlugin {
 												} else if (
 													moduleRuntime !== undefined &&
 													moduleRuntime.has(/** @type {string} */ (runtime))
-												)
+												) {
 													return;
+												}
 											}
 											const item =
 												/** @type {HotUpdateMainContentByRuntimeItem} */ (
@@ -683,15 +694,17 @@ class HotModuleReplacementPlugin {
 								(newRuntimeModules && newRuntimeModules.length > 0)
 							) {
 								const hotUpdateChunk = new HotUpdateChunk();
-								if (backCompat)
+								if (backCompat) {
 									ChunkGraph.setChunkGraphForChunk(hotUpdateChunk, chunkGraph);
+								}
 								hotUpdateChunk.id = chunkId;
 								hotUpdateChunk.runtime = currentChunk
 									? currentChunk.runtime
 									: newRuntime;
 								if (currentChunk) {
-									for (const group of currentChunk.groupsIterable)
+									for (const group of currentChunk.groupsIterable) {
 										hotUpdateChunk.addGroup(group);
+									}
 								}
 								chunkGraph.attachModules(hotUpdateChunk, newModules || []);
 								chunkGraph.attachRuntimeModules(
@@ -712,12 +725,14 @@ class HotModuleReplacementPlugin {
 								}
 								const renderManifest = compilation.getRenderManifest({
 									chunk: hotUpdateChunk,
-									hash: records.hash,
-									fullHash: records.hash,
+									hash: /** @type {string} */ (records.hash),
+									fullHash: /** @type {string} */ (records.hash),
 									outputOptions: compilation.outputOptions,
 									moduleTemplates: compilation.moduleTemplates,
 									dependencyTemplates: compilation.dependencyTemplates,
-									codeGenerationResults: compilation.codeGenerationResults,
+									codeGenerationResults: /** @type {CodeGenerationResults} */ (
+										compilation.codeGenerationResults
+									),
 									runtimeTemplate: compilation.runtimeTemplate,
 									moduleGraph: compilation.moduleGraph,
 									chunkGraph
@@ -748,7 +763,7 @@ class HotModuleReplacementPlugin {
 										compilation.hooks.chunkAsset.call(currentChunk, filename);
 									}
 								}
-								forEachRuntime(newRuntime, runtime => {
+								forEachRuntime(newRuntime, (runtime) => {
 									const item =
 										/** @type {HotUpdateMainContentByRuntimeItem} */ (
 											hotUpdateMainContentByRuntime.get(
@@ -759,9 +774,7 @@ class HotModuleReplacementPlugin {
 								});
 							}
 						}
-						const completelyRemovedModulesArray = Array.from(
-							completelyRemovedModules
-						);
+						const completelyRemovedModulesArray = [...completelyRemovedModules];
 						const hotUpdateMainContentByFilename = new Map();
 						for (const {
 							removedChunkIds,
@@ -783,12 +796,15 @@ The configured output.hotUpdateMainFilename doesn't lead to unique filenames per
 This might lead to incorrect runtime behavior of the applied update.
 To fix this, make sure to include [runtime] in the output.hotUpdateMainFilename option, or use the default config.`)
 								);
-								for (const chunkId of removedChunkIds)
+								for (const chunkId of removedChunkIds) {
 									old.removedChunkIds.add(chunkId);
-								for (const chunkId of removedModules)
+								}
+								for (const chunkId of removedModules) {
 									old.removedModules.add(chunkId);
-								for (const chunkId of updatedChunkIds)
+								}
+								for (const chunkId of updatedChunkIds) {
 									old.updatedChunkIds.add(chunkId);
+								}
 								continue;
 							}
 							hotUpdateMainContentByFilename.set(filename, {
@@ -802,22 +818,47 @@ To fix this, make sure to include [runtime] in the output.hotUpdateMainFilename
 							filename,
 							{ removedChunkIds, removedModules, updatedChunkIds, assetInfo }
 						] of hotUpdateMainContentByFilename) {
+							/** @type {{c: ChunkId[], r: ChunkId[], m: ModuleId[], css?: {r: ChunkId[]}}} */
 							const hotUpdateMainJson = {
-								c: Array.from(updatedChunkIds),
-								r: Array.from(removedChunkIds),
+								c: [...updatedChunkIds],
+								r: [...removedChunkIds],
 								m:
 									removedModules.size === 0
 										? completelyRemovedModulesArray
-										: completelyRemovedModulesArray.concat(
-												Array.from(
+										: [
+												...completelyRemovedModulesArray,
+												...Array.from(
 													removedModules,
-													m =>
+													(m) =>
 														/** @type {ModuleId} */ (chunkGraph.getModuleId(m))
 												)
-											)
+											]
 							};
 
-							const source = new RawSource(JSON.stringify(hotUpdateMainJson));
+							// Build CSS removed chunks list (chunks in updatedChunkIds that no longer have CSS)
+							/** @type {ChunkId[]} */
+							const cssRemovedChunkIds = [];
+							if (compilation.options.experiments.css) {
+								for (const chunkId of updatedChunkIds) {
+									for (const /** @type {Chunk} */ chunk of compilation.chunks) {
+										if (chunk.id === chunkId) {
+											if (!chunkHasCss(chunk, chunkGraph)) {
+												cssRemovedChunkIds.push(chunkId);
+											}
+											break;
+										}
+									}
+								}
+							}
+
+							if (cssRemovedChunkIds.length > 0) {
+								hotUpdateMainJson.css = { r: cssRemovedChunkIds };
+							}
+
+							const source = new RawSource(
+								(filename.endsWith(".json") ? "" : "export default ") +
+									JSON.stringify(hotUpdateMainJson)
+							);
 							compilation.emitAsset(filename, source, {
 								hotModuleReplacement: true,
 								...assetInfo
@@ -842,28 +883,28 @@ To fix this, make sure to include [runtime] in the output.hotUpdateMainFilename
 
 				normalModuleFactory.hooks.parser
 					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
-					.tap(PLUGIN_NAME, parser => {
+					.tap(PLUGIN_NAME, (parser) => {
 						applyModuleHot(parser);
 						applyImportMetaHot(parser);
 					});
 				normalModuleFactory.hooks.parser
 					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
-					.tap(PLUGIN_NAME, parser => {
+					.tap(PLUGIN_NAME, (parser) => {
 						applyModuleHot(parser);
 					});
 				normalModuleFactory.hooks.parser
 					.for(JAVASCRIPT_MODULE_TYPE_ESM)
-					.tap(PLUGIN_NAME, parser => {
+					.tap(PLUGIN_NAME, (parser) => {
 						applyImportMetaHot(parser);
 					});
-				normalModuleFactory.hooks.module.tap(PLUGIN_NAME, module => {
+				normalModuleFactory.hooks.module.tap(PLUGIN_NAME, (module) => {
 					module.hot = true;
 					return module;
 				});
 
 				NormalModule.getCompilationHooks(compilation).loader.tap(
 					PLUGIN_NAME,
-					context => {
+					(context) => {
 						context.hot = true;
 					}
 				);

package/lib/HotUpdateChunk.js

@@ -7,9 +7,6 @@
 
 const Chunk = require("./Chunk");
 
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./util/Hash")} Hash */
-
 class HotUpdateChunk extends Chunk {
 	constructor() {
 		super();

package/lib/IgnoreErrorModuleFactory.js

@@ -7,8 +7,8 @@
 
 const ModuleFactory = require("./ModuleFactory");
 
+/** @typedef {import("./ModuleFactory").ModuleFactoryCallback} ModuleFactoryCallback */
 /** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
 /** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
 
 /**
@@ -26,7 +26,7 @@ class IgnoreErrorModuleFactory extends ModuleFactory {
 
 	/**
 	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function((Error | null)=, ModuleFactoryResult=): void} callback callback
+	 * @param {ModuleFactoryCallback} callback callback
 	 * @returns {void}
 	 */
 	create(data, callback) {