webpack 5.59.0 → 5.94.0

package/lib/HotModuleReplacementPlugin.js

@@ -35,22 +35,43 @@ const {
 	intersectRuntime
 } = 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("../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("./Compiler")} Compiler */
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("./Module")} Module */
+/** @typedef {import("./Module").BuildInfo} BuildInfo */
 /** @typedef {import("./RuntimeModule")} RuntimeModule */
+/** @typedef {import("./javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
+/** @typedef {import("./javascript/JavascriptParserHelpers").Range} Range */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
 /**
- * @typedef {Object} HMRJavascriptParserHooks
+ * @typedef {object} HMRJavascriptParserHooks
  * @property {SyncBailHook<[TODO, string[]], void>} hotAcceptCallback
  * @property {SyncBailHook<[TODO, string[]], void>} hotAcceptWithoutCallback
  */
 
+/** @typedef {{ updatedChunkIds: Set<ChunkId>, removedChunkIds: Set<ChunkId>, removedModules: Set<Module>, filename: string, assetInfo: AssetInfo }} HotUpdateMainContentByRuntimeItem */
+/** @typedef {Map<string, HotUpdateMainContentByRuntimeItem>} HotUpdateMainContentByRuntime */
+
 /** @type {WeakMap<JavascriptParser, HMRJavascriptParserHooks>} */
 const parserHooksMap = new WeakMap();
 
+const PLUGIN_NAME = "HotModuleReplacementPlugin";
+
 class HotModuleReplacementPlugin {
 	/**
 	 * @param {JavascriptParser} parser the parser
@@ -73,6 +94,9 @@ class HotModuleReplacementPlugin {
 		return hooks;
 	}
 
+	/**
+	 * @param {object=} options options
+	 */
 	constructor(options) {
 		this.options = options || {};
 	}
@@ -83,10 +107,16 @@ class HotModuleReplacementPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
+		const { _backCompat: backCompat } = compiler;
 		if (compiler.options.output.strictModuleErrorHandling === undefined)
 			compiler.options.output.strictModuleErrorHandling = true;
 		const runtimeRequirements = [RuntimeGlobals.module];
 
+		/**
+		 * @param {JavascriptParser} parser the parser
+		 * @param {typeof ModuleHotAcceptDependency} ParamDependency dependency
+		 * @returns {(expr: CallExpression) => boolean | undefined} callback
+		 */
 		const createAcceptHandler = (parser, ParamDependency) => {
 			const { hotAcceptCallback, hotAcceptWithoutCallback } =
 				HotModuleReplacementPlugin.getParserHooks(parser);
@@ -95,41 +125,53 @@ class HotModuleReplacementPlugin {
 				const module = parser.state.module;
 				const dep = new ConstDependency(
 					`${module.moduleArgument}.hot.accept`,
-					expr.callee.range,
+					/** @type {Range} */ (expr.callee.range),
 					runtimeRequirements
 				);
-				dep.loc = expr.loc;
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 				module.addPresentationalDependency(dep);
-				module.buildInfo.moduleConcatenationBailout = "Hot Module Replacement";
+				/** @type {BuildInfo} */
+				(module.buildInfo).moduleConcatenationBailout =
+					"Hot Module Replacement";
 				if (expr.arguments.length >= 1) {
-					const arg = parser.evaluateExpression(expr.arguments[0]);
+					const arg = parser.evaluateExpression(
+						/** @type {Expression} */ (expr.arguments[0])
+					);
+					/** @type {BasicEvaluatedExpression[]} */
 					let params = [];
-					let requests = [];
 					if (arg.isString()) {
 						params = [arg];
 					} else if (arg.isArray()) {
-						params = arg.items.filter(param => param.isString());
+						params =
+							/** @type {BasicEvaluatedExpression[]} */
+							(arg.items).filter(param => param.isString());
 					}
+					/** @type {string[]} */
+					const requests = [];
 					if (params.length > 0) {
-						params.forEach((param, idx) => {
-							const request = param.string;
-							const dep = new ParamDependency(request, param.range);
+						for (const [idx, param] of params.entries()) {
+							const request = /** @type {string} */ (param.string);
+							const dep = new ParamDependency(
+								request,
+								/** @type {Range} */ (param.range)
+							);
 							dep.optional = true;
-							dep.loc = Object.create(expr.loc);
+							dep.loc = Object.create(
+								/** @type {DependencyLocation} */ (expr.loc)
+							);
 							dep.loc.index = idx;
 							module.addDependency(dep);
 							requests.push(request);
-						});
+						}
 						if (expr.arguments.length > 1) {
 							hotAcceptCallback.call(expr.arguments[1], requests);
 							for (let i = 1; i < expr.arguments.length; i++) {
 								parser.walkExpression(expr.arguments[i]);
 							}
 							return true;
-						} else {
-							hotAcceptWithoutCallback.call(expr, requests);
-							return true;
 						}
+						hotAcceptWithoutCallback.call(expr, requests);
+						return true;
 					}
 				}
 				parser.walkExpressions(expr.arguments);
@@ -137,116 +179,140 @@ class HotModuleReplacementPlugin {
 			};
 		};
 
+		/**
+		 * @param {JavascriptParser} parser the parser
+		 * @param {typeof ModuleHotDeclineDependency} ParamDependency dependency
+		 * @returns {(expr: CallExpression) => boolean | undefined} callback
+		 */
 		const createDeclineHandler = (parser, ParamDependency) => expr => {
 			const module = parser.state.module;
 			const dep = new ConstDependency(
 				`${module.moduleArgument}.hot.decline`,
-				expr.callee.range,
+				/** @type {Range} */ (expr.callee.range),
 				runtimeRequirements
 			);
-			dep.loc = expr.loc;
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 			module.addPresentationalDependency(dep);
-			module.buildInfo.moduleConcatenationBailout = "Hot Module Replacement";
+			/** @type {BuildInfo} */
+			(module.buildInfo).moduleConcatenationBailout = "Hot Module Replacement";
 			if (expr.arguments.length === 1) {
 				const arg = parser.evaluateExpression(expr.arguments[0]);
+				/** @type {BasicEvaluatedExpression[]} */
 				let params = [];
 				if (arg.isString()) {
 					params = [arg];
 				} else if (arg.isArray()) {
-					params = arg.items.filter(param => param.isString());
+					params =
+						/** @type {BasicEvaluatedExpression[]} */
+						(arg.items).filter(param => param.isString());
 				}
-				params.forEach((param, idx) => {
-					const dep = new ParamDependency(param.string, param.range);
+				for (const [idx, param] of params.entries()) {
+					const dep = new ParamDependency(
+						/** @type {string} */ (param.string),
+						/** @type {Range} */ (param.range)
+					);
 					dep.optional = true;
-					dep.loc = Object.create(expr.loc);
+					dep.loc = Object.create(/** @type {DependencyLocation} */ (expr.loc));
 					dep.loc.index = idx;
 					module.addDependency(dep);
-				});
+				}
 			}
 			return true;
 		};
 
+		/**
+		 * @param {JavascriptParser} parser the parser
+		 * @returns {(expr: Expression) => boolean | undefined} callback
+		 */
 		const createHMRExpressionHandler = parser => expr => {
 			const module = parser.state.module;
 			const dep = new ConstDependency(
 				`${module.moduleArgument}.hot`,
-				expr.range,
+				/** @type {Range} */ (expr.range),
 				runtimeRequirements
 			);
-			dep.loc = expr.loc;
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 			module.addPresentationalDependency(dep);
-			module.buildInfo.moduleConcatenationBailout = "Hot Module Replacement";
+			/** @type {BuildInfo} */
+			(module.buildInfo).moduleConcatenationBailout = "Hot Module Replacement";
 			return true;
 		};
 
+		/**
+		 * @param {JavascriptParser} parser the parser
+		 * @returns {void}
+		 */
 		const applyModuleHot = parser => {
 			parser.hooks.evaluateIdentifier.for("module.hot").tap(
 				{
-					name: "HotModuleReplacementPlugin",
+					name: PLUGIN_NAME,
 					before: "NodeStuffPlugin"
 				},
-				expr => {
-					return evaluateToIdentifier(
+				expr =>
+					evaluateToIdentifier(
 						"module.hot",
 						"module",
 						() => ["hot"],
 						true
-					)(expr);
-				}
+					)(expr)
 			);
 			parser.hooks.call
 				.for("module.hot.accept")
 				.tap(
-					"HotModuleReplacementPlugin",
+					PLUGIN_NAME,
 					createAcceptHandler(parser, ModuleHotAcceptDependency)
 				);
 			parser.hooks.call
 				.for("module.hot.decline")
 				.tap(
-					"HotModuleReplacementPlugin",
+					PLUGIN_NAME,
 					createDeclineHandler(parser, ModuleHotDeclineDependency)
 				);
 			parser.hooks.expression
 				.for("module.hot")
-				.tap("HotModuleReplacementPlugin", createHMRExpressionHandler(parser));
+				.tap(PLUGIN_NAME, createHMRExpressionHandler(parser));
 		};
 
+		/**
+		 * @param {JavascriptParser} parser the parser
+		 * @returns {void}
+		 */
 		const applyImportMetaHot = parser => {
 			parser.hooks.evaluateIdentifier
 				.for("import.meta.webpackHot")
-				.tap("HotModuleReplacementPlugin", expr => {
-					return evaluateToIdentifier(
+				.tap(PLUGIN_NAME, expr =>
+					evaluateToIdentifier(
 						"import.meta.webpackHot",
 						"import.meta",
 						() => ["webpackHot"],
 						true
-					)(expr);
-				});
+					)(expr)
+				);
 			parser.hooks.call
 				.for("import.meta.webpackHot.accept")
 				.tap(
-					"HotModuleReplacementPlugin",
+					PLUGIN_NAME,
 					createAcceptHandler(parser, ImportMetaHotAcceptDependency)
 				);
 			parser.hooks.call
 				.for("import.meta.webpackHot.decline")
 				.tap(
-					"HotModuleReplacementPlugin",
+					PLUGIN_NAME,
 					createDeclineHandler(parser, ImportMetaHotDeclineDependency)
 				);
 			parser.hooks.expression
 				.for("import.meta.webpackHot")
-				.tap("HotModuleReplacementPlugin", createHMRExpressionHandler(parser));
+				.tap(PLUGIN_NAME, createHMRExpressionHandler(parser));
 		};
 
 		compiler.hooks.compilation.tap(
-			"HotModuleReplacementPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				// This applies the HMR plugin only to the targeted compiler
 				// It should not affect child compilations
 				if (compilation.compiler !== compiler) return;
 
-				//#region module.hot.* API
+				// #region module.hot.* API
 				compilation.dependencyFactories.set(
 					ModuleHotAcceptDependency,
 					normalModuleFactory
@@ -263,9 +329,9 @@ class HotModuleReplacementPlugin {
 					ModuleHotDeclineDependency,
 					new ModuleHotDeclineDependency.Template()
 				);
-				//#endregion
+				// #endregion
 
-				//#region import.meta.webpackHot.* API
+				// #region import.meta.webpackHot.* API
 				compilation.dependencyFactories.set(
 					ImportMetaHotAcceptDependency,
 					normalModuleFactory
@@ -282,49 +348,54 @@ class HotModuleReplacementPlugin {
 					ImportMetaHotDeclineDependency,
 					new ImportMetaHotDeclineDependency.Template()
 				);
-				//#endregion
+				// #endregion
 
 				let hotIndex = 0;
+				/** @type {Record<string, string>} */
 				const fullHashChunkModuleHashes = {};
+				/** @type {Record<string, string>} */
 				const chunkModuleHashes = {};
 
-				compilation.hooks.record.tap(
-					"HotModuleReplacementPlugin",
-					(compilation, records) => {
-						if (records.hash === compilation.hash) return;
-						const chunkGraph = compilation.chunkGraph;
-						records.hash = compilation.hash;
-						records.hotIndex = hotIndex;
-						records.fullHashChunkModuleHashes = fullHashChunkModuleHashes;
-						records.chunkModuleHashes = chunkModuleHashes;
-						records.chunkHashes = {};
-						records.chunkRuntime = {};
-						for (const chunk of compilation.chunks) {
-							records.chunkHashes[chunk.id] = chunk.hash;
-							records.chunkRuntime[chunk.id] = getRuntimeKey(chunk.runtime);
-						}
-						records.chunkModuleIds = {};
-						for (const chunk of compilation.chunks) {
-							records.chunkModuleIds[chunk.id] = Array.from(
+				compilation.hooks.record.tap(PLUGIN_NAME, (compilation, records) => {
+					if (records.hash === compilation.hash) return;
+					const chunkGraph = compilation.chunkGraph;
+					records.hash = compilation.hash;
+					records.hotIndex = hotIndex;
+					records.fullHashChunkModuleHashes = fullHashChunkModuleHashes;
+					records.chunkModuleHashes = chunkModuleHashes;
+					records.chunkHashes = {};
+					records.chunkRuntime = {};
+					for (const chunk of compilation.chunks) {
+						const chunkId = /** @type {ChunkId} */ (chunk.id);
+						records.chunkHashes[chunkId] = 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)
 							);
-						}
 					}
-				);
+				});
 				/** @type {TupleSet<[Module, Chunk]>} */
 				const updatedModules = new TupleSet();
 				/** @type {TupleSet<[Module, Chunk]>} */
 				const fullHashModules = new TupleSet();
 				/** @type {TupleSet<[Module, RuntimeSpec]>} */
 				const nonCodeGeneratedModules = new TupleSet();
-				compilation.hooks.fullHash.tap("HotModuleReplacementPlugin", hash => {
+				compilation.hooks.fullHash.tap(PLUGIN_NAME, hash => {
 					const chunkGraph = compilation.chunkGraph;
 					const 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)
@@ -333,10 +404,9 @@ class HotModuleReplacementPlugin {
 									module,
 									chunk.runtime
 								);
-							} else {
-								nonCodeGeneratedModules.add(module, chunk.runtime);
-								return chunkGraph.getModuleHash(module, chunk.runtime);
 							}
+							nonCodeGeneratedModules.add(module, chunk.runtime);
+							return chunkGraph.getModuleHash(module, chunk.runtime);
 						};
 						const fullHashModulesInThisChunk =
 							chunkGraph.getChunkFullHashModulesSet(chunk);
@@ -378,28 +448,26 @@ class HotModuleReplacementPlugin {
 										chunkModuleHashes[key] = hash;
 									}
 								}
-							} else {
-								if (fullHashModulesInThisChunk !== undefined) {
-									for (const module of modules) {
-										const key = `${chunk.id}|${module.identifier()}`;
-										const hash = getModuleHash(module);
-										if (
-											fullHashModulesInThisChunk.has(
-												/** @type {RuntimeModule} */ (module)
-											)
-										) {
-											fullHashChunkModuleHashes[key] = hash;
-										} else {
-											chunkModuleHashes[key] = hash;
-										}
-									}
-								} else {
-									for (const module of modules) {
-										const key = `${chunk.id}|${module.identifier()}`;
-										const hash = getModuleHash(module);
+							} else if (fullHashModulesInThisChunk !== undefined) {
+								for (const module of modules) {
+									const key = `${chunk.id}|${module.identifier()}`;
+									const hash = getModuleHash(module);
+									if (
+										fullHashModulesInThisChunk.has(
+											/** @type {RuntimeModule} */ (module)
+										)
+									) {
+										fullHashChunkModuleHashes[key] = hash;
+									} else {
 										chunkModuleHashes[key] = hash;
 									}
 								}
+							} else {
+								for (const module of modules) {
+									const key = `${chunk.id}|${module.identifier()}`;
+									const hash = getModuleHash(module);
+									chunkModuleHashes[key] = hash;
+								}
 							}
 						}
 					}
@@ -411,7 +479,7 @@ class HotModuleReplacementPlugin {
 				});
 				compilation.hooks.processAssets.tap(
 					{
-						name: "HotModuleReplacementPlugin",
+						name: PLUGIN_NAME,
 						stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL
 					},
 					() => {
@@ -432,14 +500,14 @@ class HotModuleReplacementPlugin {
 								: compilation.codeGenerationResults.getHash(
 										module,
 										chunk.runtime
-								  );
+									);
 							if (records.chunkModuleHashes[key] !== hash) {
 								updatedModules.add(module, chunk);
 							}
 							chunkModuleHashes[key] = hash;
 						}
 
-						/** @type {Map<string, { updatedChunkIds: Set<string|number>, removedChunkIds: Set<string|number>, removedModules: Set<Module>, filename: string, assetInfo: AssetInfo }>} */
+						/** @type {HotUpdateMainContentByRuntime} */
 						const hotUpdateMainContentByRuntime = new Map();
 						let allOldRuntime;
 						for (const key of Object.keys(records.chunkRuntime)) {
@@ -449,19 +517,23 @@ class HotModuleReplacementPlugin {
 						forEachRuntime(allOldRuntime, runtime => {
 							const { path: filename, info: assetInfo } =
 								compilation.getPathWithInfo(
-									compilation.outputOptions.hotUpdateMainFilename,
+									/** @type {NonNullable<OutputNormalized["hotUpdateMainFilename"]>} */
+									(compilation.outputOptions.hotUpdateMainFilename),
 									{
 										hash: records.hash,
 										runtime
 									}
 								);
-							hotUpdateMainContentByRuntime.set(runtime, {
-								updatedChunkIds: new Set(),
-								removedChunkIds: new Set(),
-								removedModules: new Set(),
-								filename,
-								assetInfo
-							});
+							hotUpdateMainContentByRuntime.set(
+								/** @type {string} */ (runtime),
+								{
+									updatedChunkIds: new Set(),
+									removedChunkIds: new Set(),
+									removedModules: new Set(),
+									filename,
+									assetInfo
+								}
+							);
 						});
 						if (hotUpdateMainContentByRuntime.size === 0) return;
 
@@ -469,7 +541,9 @@ class HotModuleReplacementPlugin {
 						/** @type {Map<number|string, Module>} */
 						const allModules = new Map();
 						for (const module of compilation.modules) {
-							const id = chunkGraph.getModuleId(module);
+							const id =
+								/** @type {ModuleId} */
+								(chunkGraph.getModuleId(module));
 							allModules.set(id, module);
 						}
 
@@ -491,6 +565,7 @@ class HotModuleReplacementPlugin {
 								}
 							}
 
+							/** @type {ChunkId | null} */
 							let chunkId;
 							let newModules;
 							let newRuntimeModules;
@@ -532,16 +607,21 @@ class HotModuleReplacementPlugin {
 								removedFromRuntime = subtractRuntime(oldRuntime, newRuntime);
 							} else {
 								// chunk has completely removed
-								chunkId = `${+key}` === key ? +key : key;
+								chunkId = `${Number(key)}` === key ? Number(key) : key;
 								removedFromRuntime = oldRuntime;
 								newRuntime = oldRuntime;
 							}
 							if (removedFromRuntime) {
 								// chunk was removed from some runtimes
 								forEachRuntime(removedFromRuntime, runtime => {
-									hotUpdateMainContentByRuntime
-										.get(runtime)
-										.removedChunkIds.add(chunkId);
+									const item =
+										/** @type {HotUpdateMainContentByRuntimeItem} */
+										(
+											hotUpdateMainContentByRuntime.get(
+												/** @type {string} */ (runtime)
+											)
+										);
+									item.removedChunkIds.add(/** @type {ChunkId} */ (chunkId));
 								});
 								// dispose modules from the chunk in these runtimes
 								// where they are no longer in this runtime
@@ -556,9 +636,9 @@ class HotModuleReplacementPlugin {
 											: compilation.codeGenerationResults.getHash(
 													module,
 													newRuntime
-											  );
+												);
 										if (hash !== oldHash) {
-											if (module.type === "runtime") {
+											if (module.type === WEBPACK_MODULE_TYPE_RUNTIME) {
 												newRuntimeModules = newRuntimeModules || [];
 												newRuntimeModules.push(
 													/** @type {RuntimeModule} */ (module)
@@ -581,13 +661,19 @@ class HotModuleReplacementPlugin {
 											for (const moduleRuntime of runtimes) {
 												if (typeof moduleRuntime === "string") {
 													if (moduleRuntime === runtime) return;
-												} else if (moduleRuntime !== undefined) {
-													if (moduleRuntime.has(runtime)) return;
-												}
+												} else if (
+													moduleRuntime !== undefined &&
+													moduleRuntime.has(/** @type {string} */ (runtime))
+												)
+													return;
 											}
-											hotUpdateMainContentByRuntime
-												.get(runtime)
-												.removedModules.add(module);
+											const item =
+												/** @type {HotUpdateMainContentByRuntimeItem} */ (
+													hotUpdateMainContentByRuntime.get(
+														/** @type {string} */ (runtime)
+													)
+												);
+											item.removedModules.add(module);
 										});
 									}
 								}
@@ -597,7 +683,8 @@ class HotModuleReplacementPlugin {
 								(newRuntimeModules && newRuntimeModules.length > 0)
 							) {
 								const hotUpdateChunk = new HotUpdateChunk();
-								ChunkGraph.setChunkGraphForChunk(hotUpdateChunk, chunkGraph);
+								if (backCompat)
+									ChunkGraph.setChunkGraphForChunk(hotUpdateChunk, chunkGraph);
 								hotUpdateChunk.id = chunkId;
 								hotUpdateChunk.runtime = newRuntime;
 								if (currentChunk) {
@@ -660,9 +747,13 @@ class HotModuleReplacementPlugin {
 									}
 								}
 								forEachRuntime(newRuntime, runtime => {
-									hotUpdateMainContentByRuntime
-										.get(runtime)
-										.updatedChunkIds.add(chunkId);
+									const item =
+										/** @type {HotUpdateMainContentByRuntimeItem} */ (
+											hotUpdateMainContentByRuntime.get(
+												/** @type {string} */ (runtime)
+											)
+										);
+									item.updatedChunkIds.add(/** @type {ChunkId} */ (chunkId));
 								});
 							}
 						}
@@ -716,10 +807,12 @@ To fix this, make sure to include [runtime] in the output.hotUpdateMainFilename
 									removedModules.size === 0
 										? completelyRemovedModulesArray
 										: completelyRemovedModulesArray.concat(
-												Array.from(removedModules, m =>
-													chunkGraph.getModuleId(m)
+												Array.from(
+													removedModules,
+													m =>
+														/** @type {ModuleId} */ (chunkGraph.getModuleId(m))
 												)
-										  )
+											)
 							};
 
 							const source = new RawSource(JSON.stringify(hotUpdateMainJson));
@@ -732,7 +825,7 @@ To fix this, make sure to include [runtime] in the output.hotUpdateMainFilename
 				);
 
 				compilation.hooks.additionalTreeRuntimeRequirements.tap(
-					"HotModuleReplacementPlugin",
+					PLUGIN_NAME,
 					(chunk, runtimeRequirements) => {
 						runtimeRequirements.add(RuntimeGlobals.hmrDownloadManifest);
 						runtimeRequirements.add(RuntimeGlobals.hmrDownloadUpdateHandlers);
@@ -746,24 +839,24 @@ To fix this, make sure to include [runtime] in the output.hotUpdateMainFilename
 				);
 
 				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("HotModuleReplacementPlugin", parser => {
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, parser => {
 						applyModuleHot(parser);
 						applyImportMetaHot(parser);
 					});
 				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("HotModuleReplacementPlugin", parser => {
+					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
+					.tap(PLUGIN_NAME, parser => {
 						applyModuleHot(parser);
 					});
 				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("HotModuleReplacementPlugin", parser => {
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, parser => {
 						applyImportMetaHot(parser);
 					});
 
 				NormalModule.getCompilationHooks(compilation).loader.tap(
-					"HotModuleReplacementPlugin",
+					PLUGIN_NAME,
 					context => {
 						context.hot = true;
 					}