webpack 5.99.6 → 5.99.8

package/lib/cache/IdleFileCachePlugin.js

@@ -12,6 +12,7 @@ const ProgressPlugin = require("../ProgressPlugin");
 /** @typedef {import("./PackFileCacheStrategy")} PackFileCacheStrategy */
 
 const BUILD_DEPENDENCIES_KEY = Symbol("build dependencies key");
+const PLUGIN_NAME = "IdleFileCachePlugin";
 
 class IdleFileCachePlugin {
 	/**
@@ -55,7 +56,7 @@ class IdleFileCachePlugin {
 		const pendingIdleTasks = new Map();
 
 		compiler.cache.hooks.store.tap(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_DISK },
 			(identifier, etag, data) => {
 				pendingIdleTasks.set(identifier, () =>
 					strategy.store(identifier, etag, data)
@@ -64,7 +65,7 @@ class IdleFileCachePlugin {
 		);
 
 		compiler.cache.hooks.get.tapPromise(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_DISK },
 			(identifier, etag, gotHandlers) => {
 				const restore = () =>
 					strategy.restore(identifier, etag).then(cacheEntry => {
@@ -91,7 +92,7 @@ class IdleFileCachePlugin {
 		);
 
 		compiler.cache.hooks.storeBuildDependencies.tap(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_DISK },
 			dependencies => {
 				pendingIdleTasks.set(BUILD_DEPENDENCIES_KEY, () =>
 					Promise.resolve().then(() =>
@@ -102,7 +103,7 @@ class IdleFileCachePlugin {
 		);
 
 		compiler.cache.hooks.shutdown.tapPromise(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_DISK },
 			() => {
 				if (idleTimer) {
 					clearTimeout(idleTimer);
@@ -165,9 +166,7 @@ class IdleFileCachePlugin {
 						timeSpendInBuild = 0;
 					})
 					.catch(err => {
-						const logger = compiler.getInfrastructureLogger(
-							"IdleFileCachePlugin"
-						);
+						const logger = compiler.getInfrastructureLogger(PLUGIN_NAME);
 						logger.warn(`Background tasks during idle failed: ${err.message}`);
 						logger.debug(err.stack);
 					});
@@ -177,12 +176,12 @@ class IdleFileCachePlugin {
 		/** @type {ReturnType<typeof setTimeout> | undefined} */
 		let idleTimer;
 		compiler.cache.hooks.beginIdle.tap(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_DISK },
 			() => {
 				const isLargeChange = timeSpendInBuild > avgTimeSpendInStore * 2;
 				if (isInitialStore && idleTimeoutForInitialStore < idleTimeout) {
 					compiler
-						.getInfrastructureLogger("IdleFileCachePlugin")
+						.getInfrastructureLogger(PLUGIN_NAME)
 						.log(
 							`Initial cache was generated and cache will be persisted in ${
 								idleTimeoutForInitialStore / 1000
@@ -193,7 +192,7 @@ class IdleFileCachePlugin {
 					idleTimeoutAfterLargeChanges < idleTimeout
 				) {
 					compiler
-						.getInfrastructureLogger("IdleFileCachePlugin")
+						.getInfrastructureLogger(PLUGIN_NAME)
 						.log(
 							`Spend ${Math.round(timeSpendInBuild) / 1000}s in build and ${
 								Math.round(avgTimeSpendInStore) / 1000
@@ -218,7 +217,7 @@ class IdleFileCachePlugin {
 			}
 		);
 		compiler.cache.hooks.endIdle.tap(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_DISK },
 			() => {
 				if (idleTimer) {
 					clearTimeout(idleTimer);
@@ -227,7 +226,7 @@ class IdleFileCachePlugin {
 				isIdle = false;
 			}
 		);
-		compiler.hooks.done.tap("IdleFileCachePlugin", stats => {
+		compiler.hooks.done.tap(PLUGIN_NAME, stats => {
 			// 10% build overhead is ignored, as it's not cacheable
 			timeSpendInBuild *= 0.9;
 			timeSpendInBuild +=

package/lib/cache/MemoryWithGcCachePlugin.js

@@ -18,6 +18,8 @@ const Cache = require("../Cache");
  * @property {number} maxGenerations max generations
  */
 
+const PLUGIN_NAME = "MemoryWithGcCachePlugin";
+
 class MemoryWithGcCachePlugin {
 	/**
 	 * @param {MemoryWithGcCachePluginOptions} options options
@@ -39,8 +41,8 @@ class MemoryWithGcCachePlugin {
 		const oldCache = new Map();
 		let generation = 0;
 		let cachePosition = 0;
-		const logger = compiler.getInfrastructureLogger("MemoryWithGcCachePlugin");
-		compiler.hooks.afterDone.tap("MemoryWithGcCachePlugin", () => {
+		const logger = compiler.getInfrastructureLogger(PLUGIN_NAME);
+		compiler.hooks.afterDone.tap(PLUGIN_NAME, () => {
 			generation++;
 			let clearedEntries = 0;
 			let lastClearedIdentifier;
@@ -91,13 +93,13 @@ class MemoryWithGcCachePlugin {
 			}
 		});
 		compiler.cache.hooks.store.tap(
-			{ name: "MemoryWithGcCachePlugin", stage: Cache.STAGE_MEMORY },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_MEMORY },
 			(identifier, etag, data) => {
 				cache.set(identifier, { etag, data });
 			}
 		);
 		compiler.cache.hooks.get.tap(
-			{ name: "MemoryWithGcCachePlugin", stage: Cache.STAGE_MEMORY },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_MEMORY },
 			(identifier, etag, gotHandlers) => {
 				const cacheEntry = cache.get(identifier);
 				if (cacheEntry === null) {
@@ -129,7 +131,7 @@ class MemoryWithGcCachePlugin {
 			}
 		);
 		compiler.cache.hooks.shutdown.tap(
-			{ name: "MemoryWithGcCachePlugin", stage: Cache.STAGE_MEMORY },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_MEMORY },
 			() => {
 				cache.clear();
 				oldCache.clear();

package/lib/cache/ResolverCachePlugin.js

@@ -97,6 +97,8 @@ const objectToString = (object, excludeContext) => {
 
 /** @typedef {NonNullable<ResolveContext["yield"]>} Yield */
 
+const PLUGIN_NAME = "ResolverCachePlugin";
+
 class ResolverCachePlugin {
 	/**
 	 * Apply the plugin
@@ -104,7 +106,7 @@ class ResolverCachePlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		const cache = compiler.getCache("ResolverCachePlugin");
+		const cache = compiler.getCache(PLUGIN_NAME);
 		/** @type {FileSystemInfo} */
 		let fileSystemInfo;
 		/** @type {SnapshotOptions | undefined} */
@@ -113,12 +115,12 @@ class ResolverCachePlugin {
 		let cachedResolves = 0;
 		let cacheInvalidResolves = 0;
 		let concurrentResolves = 0;
-		compiler.hooks.thisCompilation.tap("ResolverCachePlugin", compilation => {
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, compilation => {
 			snapshotOptions = compilation.options.snapshot.resolve;
 			fileSystemInfo = compilation.fileSystemInfo;
-			compilation.hooks.finishModules.tap("ResolverCachePlugin", () => {
+			compilation.hooks.finishModules.tap(PLUGIN_NAME, () => {
 				if (realResolves + cachedResolves > 0) {
-					const logger = compilation.getLogger("webpack.ResolverCachePlugin");
+					const logger = compilation.getLogger(`webpack.${PLUGIN_NAME}`);
 					logger.log(
 						`${Math.round(
 							(100 * realResolves) / (realResolves + cachedResolves)
@@ -260,7 +262,7 @@ class ResolverCachePlugin {
 				const hook =
 					/** @type {SyncHook<[Resolver, ResolveOptions, ResolveOptionsWithDependencyType]>} */
 					(_hook);
-				hook.tap("ResolverCachePlugin", (resolver, options, userOptions) => {
+				hook.tap(PLUGIN_NAME, (resolver, options, userOptions) => {
 					if (
 						/** @type {ResolveOptions & { cache: boolean }} */
 						(options).cache !== true
@@ -273,7 +275,7 @@ class ResolverCachePlugin {
 							: false;
 					resolver.hooks.resolve.tapAsync(
 						{
-							name: "ResolverCachePlugin",
+							name: PLUGIN_NAME,
 							stage: -100
 						},
 						(request, resolveContext, callback) => {

package/lib/cli.js

@@ -8,7 +8,11 @@
 const path = require("path");
 const webpackSchema = require("../schemas/WebpackOptions.json");
 
-/** @typedef {Parameters<import("schema-utils").validate>[0] & { absolutePath: boolean, instanceof: string, cli: { helper?: boolean, exclude?: boolean, description?: string, negatedDescription?: string, resetDescription?: string } }} Schema */
+/** @typedef {import("json-schema").JSONSchema4} JSONSchema4 */
+/** @typedef {import("json-schema").JSONSchema6} JSONSchema6 */
+/** @typedef {import("json-schema").JSONSchema7} JSONSchema7 */
+/** @typedef {JSONSchema4 | JSONSchema6 | JSONSchema7} JSONSchema */
+/** @typedef {JSONSchema & { absolutePath: boolean, instanceof: string, cli: { helper?: boolean, exclude?: boolean, description?: string, negatedDescription?: string, resetDescription?: string } }} Schema */
 
 // TODO add originPath to PathItem for better errors
 /**

package/lib/config/defaults.js

@@ -648,11 +648,14 @@ const applyModuleDefaults = (
 			"unsafeCache",
 			/**
 			 * @param {Module} module module
-			 * @returns {boolean | null | string} true, if we want to cache the module
+			 * @returns {boolean} true, if we want to cache the module
 			 */
 			module => {
 				const name = module.nameForCondition();
-				return name && NODE_MODULES_REGEXP.test(name);
+				if (!name) {
+					return false;
+				}
+				return NODE_MODULES_REGEXP.test(name);
 			}
 		);
 	} else {
@@ -683,7 +686,8 @@ const applyModuleDefaults = (
 	F(module.parser, "javascript", () => ({}));
 	F(module.parser, JSON_MODULE_TYPE, () => ({}));
 	D(
-		module.parser[JSON_MODULE_TYPE],
+		/** @type {NonNullable<ParserOptionsByModuleTypeKnown[JSON_MODULE_TYPE]>} */
+		(module.parser[JSON_MODULE_TYPE]),
 		"exportsDepth",
 		mode === "development" ? 1 : Infinity
 	);
@@ -1551,7 +1555,7 @@ const applyOptimizationDefaults = (
 							passes: 2
 						}
 					}
-				}).apply(/** @type {TODO} */ (compiler));
+				}).apply(/** @type {EXPECTED_ANY} */ (compiler));
 			}
 		}
 	]);
@@ -1726,8 +1730,8 @@ const getResolveLoaderDefaults = ({ cache }) => {
 const applyInfrastructureLoggingDefaults = infrastructureLogging => {
 	F(infrastructureLogging, "stream", () => process.stderr);
 	const tty =
-		/** @type {EXPECTED_ANY} */ (infrastructureLogging.stream).isTTY &&
-		process.env.TERM !== "dumb";
+		/** @type {NonNullable<InfrastructureLogging["stream"]>} */
+		(infrastructureLogging.stream).isTTY && process.env.TERM !== "dumb";
 	D(infrastructureLogging, "level", "info");
 	D(infrastructureLogging, "debug", false);
 	D(infrastructureLogging, "colors", tty);

package/lib/config/normalization.js

@@ -22,6 +22,7 @@ const util = require("util");
 /** @typedef {import("../../declarations/WebpackOptions").WebpackOptions} WebpackOptions */
 /** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptionsNormalized */
 /** @typedef {import("../Entrypoint")} Entrypoint */
+/** @typedef {import("../WebpackError")} WebpackError */
 
 const handledDeprecatedNoEmitOnErrors = util.deprecate(
 	/**
@@ -210,14 +211,19 @@ const getNormalizedWebpackOptions = config => ({
 					}
 					if (
 						i.module &&
-						(!warning.module ||
+						(!(/** @type {WebpackError} */ (warning).module) ||
 							!i.module.test(
-								warning.module.readableIdentifier(requestShortener)
+								/** @type {WebpackError} */
+								(warning).module.readableIdentifier(requestShortener)
 							))
 					) {
 						return false;
 					}
-					if (i.file && (!warning.file || !i.file.test(warning.file))) {
+					if (
+						i.file &&
+						(!(/** @type {WebpackError} */ (warning).file) ||
+							!i.file.test(/** @type {WebpackError} */ (warning).file))
+					) {
 						return false;
 					}
 					return true;
@@ -543,16 +549,16 @@ const getNormalizedOptimizationRuntimeChunk = runtimeChunk => {
 	}
 	if (runtimeChunk === true || runtimeChunk === "multiple") {
 		return {
-			/**
-			 * @param {Entrypoint} entrypoint entrypoint
-			 * @returns {string} runtime chunk name
-			 */
 			name: entrypoint => `runtime~${entrypoint.name}`
 		};
 	}
 	const { name } = runtimeChunk;
 	return {
-		name: typeof name === "function" ? name : () => name
+		name:
+			typeof name === "function"
+				? /** @type {Exclude<OptimizationRuntimeChunkNormalized, false>["name"]} */
+					(name)
+				: () => /** @type {string} */ (name)
 	};
 };
 

package/lib/container/ContainerReferencePlugin.js

@@ -31,6 +31,7 @@ const validate = createSchemaValidation(
 );
 
 const slashCode = "/".charCodeAt(0);
+const PLUGIN_NAME = "ContainerReferencePlugin";
 
 class ContainerReferencePlugin {
 	/**
@@ -79,7 +80,7 @@ class ContainerReferencePlugin {
 		new ExternalsPlugin(remoteType, remoteExternals).apply(compiler);
 
 		compiler.hooks.compilation.tap(
-			"ContainerReferencePlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
 					RemoteToExternalDependency,
@@ -96,37 +97,34 @@ class ContainerReferencePlugin {
 					new FallbackModuleFactory()
 				);
 
-				normalModuleFactory.hooks.factorize.tap(
-					"ContainerReferencePlugin",
-					data => {
-						if (!data.request.includes("!")) {
-							for (const [key, config] of remotes) {
-								if (
-									data.request.startsWith(`${key}`) &&
-									(data.request.length === key.length ||
-										data.request.charCodeAt(key.length) === slashCode)
-								) {
-									return new RemoteModule(
-										data.request,
-										config.external.map((external, i) =>
-											external.startsWith("internal ")
-												? external.slice(9)
-												: `webpack/container/reference/${key}${
-														i ? `/fallback-${i}` : ""
-													}`
-										),
-										`.${data.request.slice(key.length)}`,
-										config.shareScope
-									);
-								}
+				normalModuleFactory.hooks.factorize.tap(PLUGIN_NAME, data => {
+					if (!data.request.includes("!")) {
+						for (const [key, config] of remotes) {
+							if (
+								data.request.startsWith(`${key}`) &&
+								(data.request.length === key.length ||
+									data.request.charCodeAt(key.length) === slashCode)
+							) {
+								return new RemoteModule(
+									data.request,
+									config.external.map((external, i) =>
+										external.startsWith("internal ")
+											? external.slice(9)
+											: `webpack/container/reference/${key}${
+													i ? `/fallback-${i}` : ""
+												}`
+									),
+									`.${data.request.slice(key.length)}`,
+									config.shareScope
+								);
 							}
 						}
 					}
-				);
+				});
 
 				compilation.hooks.runtimeRequirementInTree
 					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("ContainerReferencePlugin", (chunk, set) => {
+					.tap(PLUGIN_NAME, (chunk, set) => {
 						set.add(RuntimeGlobals.module);
 						set.add(RuntimeGlobals.moduleFactoriesAddOnly);
 						set.add(RuntimeGlobals.hasOwnProperty);

package/lib/container/ModuleFederationPlugin.js

@@ -37,6 +37,7 @@ const validate = createSchemaValidation(
 
 /** @type {WeakMap<Compilation, CompilationHooks>} */
 const compilationHooksMap = new WeakMap();
+const PLUGIN_NAME = "ModuleFederationPlugin";
 
 class ModuleFederationPlugin {
 	/**
@@ -89,7 +90,7 @@ class ModuleFederationPlugin {
 		) {
 			compiler.options.output.enabledLibraryTypes.push(library.type);
 		}
-		compiler.hooks.afterPlugins.tap("ModuleFederationPlugin", () => {
+		compiler.hooks.afterPlugins.tap(PLUGIN_NAME, () => {
 			if (
 				options.exposes &&
 				(Array.isArray(options.exposes)

package/lib/css/CssGenerator.js

@@ -292,7 +292,7 @@ class CssGenerator extends Generator {
 					Array.from(exports).reduce((obj, [key, value]) => {
 						obj[key] = value;
 						return obj;
-					}, {})
+					}, /** @type {Record<string, string>} */ ({}))
 				);
 
 				return stringifiedExports.length + 42;

package/lib/css/CssModulesPlugin.js

@@ -48,6 +48,7 @@ const CssGenerator = require("./CssGenerator");
 const CssParser = require("./CssParser");
 
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").HashFunction} HashFunction */
 /** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} OutputOptions */
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
@@ -60,7 +61,6 @@ const CssParser = require("./CssParser");
 /** @typedef {import("../Template").RuntimeTemplate} RuntimeTemplate */
 /** @typedef {import("../TemplatedPathPlugin").TemplatePath} TemplatePath */
 /** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/createHash").Algorithm} Algorithm */
 /** @typedef {import("../util/memoize")} Memoize */
 
 /**
@@ -385,15 +385,17 @@ class CssModulesPlugin {
 					compilation
 				).renderModuleContent.tap(PLUGIN_NAME, (source, module) => {
 					if (module instanceof CssModule && module.hot) {
-						const exports =
-							/** @type {BuildInfo} */
-							(module.buildInfo).cssData.exports;
+						const cssData = /** @type {BuildInfo} */ (module.buildInfo).cssData;
+						if (!cssData) {
+							return source;
+						}
+						const exports = cssData.exports;
 						const stringifiedExports = JSON.stringify(
 							JSON.stringify(
 								Array.from(exports).reduce((obj, [key, value]) => {
 									obj[key] = value;
 									return obj;
-								}, {})
+								}, /** @type {Record<string, string>} */ ({}))
 							)
 						);
 
@@ -442,7 +444,7 @@ class CssModulesPlugin {
 							hashFunction
 						}
 					} = compilation;
-					const hash = createHash(/** @type {Algorithm} */ (hashFunction));
+					const hash = createHash(/** @type {HashFunction} */ (hashFunction));
 					if (hashSalt) hash.update(hashSalt);
 					hooks.chunkHash.call(chunk, hash, {
 						chunkGraph,

package/lib/debug/ProfilingPlugin.js

@@ -14,6 +14,7 @@ const {
 const createSchemaValidation = require("../util/create-schema-validation");
 const { dirname, mkdirpSync } = require("../util/fs");
 
+/** @typedef {import("inspector").Session} Session */
 /** @typedef {import("tapable").FullTap} FullTap */
 /** @typedef {import("../../declarations/plugins/debug/ProfilingPlugin").ProfilingPluginOptions} ProfilingPluginOptions */
 /** @typedef {import("../Compilation")} Compilation */
@@ -25,8 +26,6 @@ const { dirname, mkdirpSync } = require("../util/fs");
 /** @typedef {import("../ResolverFactory")} ResolverFactory */
 /** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
 
-/** @typedef {TODO} Inspector */
-
 const validate = createSchemaValidation(
 	require("../../schemas/plugins/debug/ProfilingPlugin.check.js"),
 	() => require("../../schemas/plugins/debug/ProfilingPlugin.json"),
@@ -36,6 +35,8 @@ const validate = createSchemaValidation(
 	}
 );
 
+/** @typedef {{ Session: typeof import("inspector").Session }} Inspector */
+
 /** @type {Inspector | undefined} */
 let inspector;
 
@@ -52,6 +53,7 @@ class Profiler {
 	 * @param {Inspector} inspector inspector
 	 */
 	constructor(inspector) {
+		/** @type {undefined | Session} */
 		this.session = undefined;
 		this.inspector = inspector;
 		this._startTime = 0;
@@ -67,8 +69,9 @@ class Profiler {
 		}
 
 		try {
-			this.session = new inspector.Session();
-			this.session.connect();
+			this.session = new /** @type {Inspector} */ (inspector).Session();
+			/** @type {Session} */
+			(this.session).connect();
 		} catch (_) {
 			this.session = undefined;
 			return Promise.resolve();
@@ -88,27 +91,20 @@ class Profiler {
 
 	/**
 	 * @param {string} method method name
-	 * @param {Record<string, EXPECTED_ANY>=} params params
-	 * @returns {Promise<TODO>} Promise for the result
+	 * @param {EXPECTED_OBJECT=} params params
+	 * @returns {Promise<EXPECTED_ANY | void>} Promise for the result
 	 */
 	sendCommand(method, params) {
 		if (this.hasSession()) {
 			return new Promise((res, rej) => {
-				this.session.post(
-					method,
-					params,
-					/**
-					 * @param {Error | null} err error
-					 * @param {object} params params
-					 */
-					(err, params) => {
-						if (err !== null) {
-							rej(err);
-						} else {
-							res(params);
-						}
+				/** @type {Session} */
+				(this.session).post(method, params, (err, params) => {
+					if (err !== null) {
+						rej(err);
+					} else {
+						res(params);
 					}
-				);
+				});
 			});
 		}
 		return Promise.resolve();
@@ -116,7 +112,8 @@ class Profiler {
 
 	destroy() {
 		if (this.hasSession()) {
-			this.session.disconnect();
+			/** @type {Session} */
+			(this.session).disconnect();
 		}
 
 		return Promise.resolve();

package/lib/dependencies/CommonJsImportsParserPlugin.js

@@ -204,7 +204,7 @@ class CommonJsImportsParserPlugin {
 				{
 					request: /** @type {string} */ (options.unknownContextRequest),
 					recursive: /** @type {boolean} */ (options.unknownContextRecursive),
-					regExp: /** @type {TODO} */ (options.unknownContextRegExp),
+					regExp: /** @type {RegExp} */ (options.unknownContextRegExp),
 					mode: "sync"
 				},
 				/** @type {Range} */ (expr.range),

package/lib/dependencies/ContextElementDependency.js

@@ -22,7 +22,7 @@ const ModuleDependency = require("./ModuleDependency");
 class ContextElementDependency extends ModuleDependency {
 	/**
 	 * @param {string} request request
-	 * @param {string|undefined} userRequest user request
+	 * @param {string | undefined} userRequest user request
 	 * @param {string | undefined} typePrefix type prefix
 	 * @param {string} category category
 	 * @param {(string[][] | null)=} referencedExports referenced exports

package/lib/dependencies/CssLocalIdentifierDependency.js

@@ -15,6 +15,7 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../../declarations/WebpackOptions").CssGeneratorExportsConvention} CssGeneratorExportsConvention */
 /** @typedef {import("../../declarations/WebpackOptions").CssGeneratorLocalIdentName} CssGeneratorLocalIdentName */
+/** @typedef {import("../../declarations/WebpackOptions").HashFunction} HashFunction */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../CssModule")} CssModule */
 /** @typedef {import("../Dependency")} Dependency */
@@ -29,7 +30,6 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/createHash").Algorithm} Algorithm */
 
 const getCssParser = memoize(() => require("../css/CssParser"));
 
@@ -53,7 +53,7 @@ const getLocalIdent = (local, module, chunkGraph, runtimeTemplate) => {
 	);
 	const { hashFunction, hashDigest, hashDigestLength, hashSalt, uniqueName } =
 		runtimeTemplate.outputOptions;
-	const hash = createHash(/** @type {Algorithm} */ (hashFunction));
+	const hash = createHash(/** @type {HashFunction} */ (hashFunction));
 
 	if (hashSalt) {
 		hash.update(hashSalt);

package/lib/dependencies/HarmonyDetectionParserPlugin.js

@@ -15,6 +15,8 @@ const HarmonyExports = require("./HarmonyExports");
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("./HarmonyModulesPlugin").HarmonyModulesPluginOptions} HarmonyModulesPluginOptions */
 
+const PLUGIN_NAME = "HarmonyDetectionParserPlugin";
+
 module.exports = class HarmonyDetectionParserPlugin {
 	/**
 	 * @param {HarmonyModulesPluginOptions} options options
@@ -29,7 +31,7 @@ module.exports = class HarmonyDetectionParserPlugin {
 	 * @returns {void}
 	 */
 	apply(parser) {
-		parser.hooks.program.tap("HarmonyDetectionParserPlugin", ast => {
+		parser.hooks.program.tap(PLUGIN_NAME, ast => {
 			const isStrictHarmony =
 				parser.state.module.type === JAVASCRIPT_MODULE_TYPE_ESM;
 			const isHarmony =
@@ -62,7 +64,7 @@ module.exports = class HarmonyDetectionParserPlugin {
 			}
 		});
 
-		parser.hooks.topLevelAwait.tap("HarmonyDetectionParserPlugin", () => {
+		parser.hooks.topLevelAwait.tap(PLUGIN_NAME, () => {
 			const module = parser.state.module;
 			if (!this.topLevelAwait) {
 				throw new Error(
@@ -105,19 +107,11 @@ module.exports = class HarmonyDetectionParserPlugin {
 		for (const identifier of nonHarmonyIdentifiers) {
 			parser.hooks.evaluateTypeof
 				.for(identifier)
-				.tap("HarmonyDetectionParserPlugin", nullInHarmony);
-			parser.hooks.typeof
-				.for(identifier)
-				.tap("HarmonyDetectionParserPlugin", skipInHarmony);
-			parser.hooks.evaluate
-				.for(identifier)
-				.tap("HarmonyDetectionParserPlugin", nullInHarmony);
-			parser.hooks.expression
-				.for(identifier)
-				.tap("HarmonyDetectionParserPlugin", skipInHarmony);
-			parser.hooks.call
-				.for(identifier)
-				.tap("HarmonyDetectionParserPlugin", skipInHarmony);
+				.tap(PLUGIN_NAME, nullInHarmony);
+			parser.hooks.typeof.for(identifier).tap(PLUGIN_NAME, skipInHarmony);
+			parser.hooks.evaluate.for(identifier).tap(PLUGIN_NAME, nullInHarmony);
+			parser.hooks.expression.for(identifier).tap(PLUGIN_NAME, skipInHarmony);
+			parser.hooks.call.for(identifier).tap(PLUGIN_NAME, skipInHarmony);
 		}
 	}
 };