webpack 5.104.1 → 5.105.0

package/lib/dependencies/ImportMetaPlugin.js

@@ -28,6 +28,7 @@ const propertyAccess = require("../util/propertyAccess");
 const ConstDependency = require("./ConstDependency");
 
 /** @typedef {import("estree").MemberExpression} MemberExpression */
+/** @typedef {import("estree").Identifier} Identifier */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
@@ -44,18 +45,24 @@ const getCriticalDependencyWarning = memoize(() =>
 
 const PLUGIN_NAME = "ImportMetaPlugin";
 
+/** @type {WeakMap<Compilation, { stringify: string, env: Record<string, string> }>} */
+const compilationMetaEnvMap = new WeakMap();
+
 /**
  * Collect import.meta.env definitions from DefinePlugin and build JSON string
  * @param {Compilation} compilation the compilation
- * @returns {string} env object as JSON string
+ * @returns {{ stringify: string, env: Record<string, string> }} env object as JSON string
  */
 const collectImportMetaEnvDefinitions = (compilation) => {
-	const definePluginHooks = DefinePlugin.getCompilationHooks(compilation);
-	const definitions = definePluginHooks.definitions.call({});
-	if (!definitions) {
-		return "{}";
+	const cached = compilationMetaEnvMap.get(compilation);
+	if (cached) {
+		return cached;
 	}
 
+	const definePluginHooks = DefinePlugin.getCompilationHooks(compilation);
+	const definitions = definePluginHooks.definitions.call({});
+	/** @type {Record<string, string>} */
+	const env = {};
 	/** @type {string[]} */
 	const pairs = [];
 	for (const key of Object.keys(definitions)) {
@@ -63,10 +70,12 @@ const collectImportMetaEnvDefinitions = (compilation) => {
 			const envKey = key.slice("import.meta.env.".length);
 			const value = definitions[key];
 			pairs.push(`${JSON.stringify(envKey)}:${value}`);
+			env[envKey] = /** @type {string} */ (value);
 		}
 	}
-
-	return `{${pairs.join(",")}}`;
+	const result = { stringify: `{${pairs.join(",")}}`, env };
+	compilationMetaEnvMap.set(compilation, result);
+	return result;
 };
 
 /**
@@ -148,10 +157,15 @@ class ImportMetaPlugin {
 					 * @param {Members} members members
 					 * @returns {string} error message
 					 */
-					const importMetaUnknownProperty = (members) =>
-						`${Template.toNormalComment(
+					const importMetaUnknownProperty = (members) => {
+						if (importMeta === "preserve-unknown") {
+							return `import.meta${propertyAccess(members, 0)}`;
+						}
+						return `${Template.toNormalComment(
 							`unsupported import.meta.${members.join(".")}`
 						)} undefined${propertyAccess(members, 1)}`;
+					};
+
 					parser.hooks.typeof
 						.for("import.meta")
 						.tap(
@@ -223,6 +237,9 @@ class ImportMetaPlugin {
 											RuntimeGlobals.module
 										);
 										break;
+									case "env":
+										str += `env: ${collectImportMetaEnvDefinitions(compilation).stringify},`;
+										break;
 									default:
 										str += `[${JSON.stringify(
 											prop.id
@@ -327,12 +344,31 @@ class ImportMetaPlugin {
 							PLUGIN_NAME,
 							toConstantDependency(parser, JSON.stringify("object"))
 						);
+					parser.hooks.expressionMemberChain
+						.for("import.meta")
+						.tap(PLUGIN_NAME, (expr, members) => {
+							if (members[0] === "env" && members[1]) {
+								const name = members[1];
+								const { env } = collectImportMetaEnvDefinitions(compilation);
+								if (!Object.prototype.hasOwnProperty.call(env, name)) {
+									const dep = new ConstDependency(
+										"undefined",
+										/** @type {Range} */ (expr.range)
+									);
+									dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+									parser.state.module.addPresentationalDependency(dep);
+									return true;
+								}
+							}
+						});
 					parser.hooks.expression
 						.for("import.meta.env")
 						.tap(PLUGIN_NAME, (expr) => {
-							const envCode = collectImportMetaEnvDefinitions(compilation);
+							const { stringify } =
+								collectImportMetaEnvDefinitions(compilation);
+
 							const dep = new ConstDependency(
-								envCode,
+								stringify,
 								/** @type {Range} */ (expr.range)
 							);
 							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
@@ -355,6 +391,11 @@ class ImportMetaPlugin {
 					parser.hooks.unhandledExpressionMemberChain
 						.for("import.meta")
 						.tap(PLUGIN_NAME, (expr, members) => {
+							// unknown import.meta properties should be determined at runtime
+							if (importMeta === "preserve-unknown") {
+								return true;
+							}
+
 							// keep import.meta.env unknown property
 							// don't evaluate import.meta.env.UNKNOWN_PROPERTY -> undefined.UNKNOWN_PROPERTY
 							// `dirname` and `filename` logic in NodeStuffPlugin
@@ -373,6 +414,7 @@ class ImportMetaPlugin {
 							parser.state.module.addPresentationalDependency(dep);
 							return true;
 						});
+
 					parser.hooks.evaluate
 						.for("MemberExpression")
 						.tap(PLUGIN_NAME, (expression) => {

package/lib/dependencies/ImportParserPlugin.js

@@ -17,7 +17,7 @@ const ContextDependencyHelpers = require("./ContextDependencyHelpers");
 const ImportContextDependency = require("./ImportContextDependency");
 const ImportDependency = require("./ImportDependency");
 const ImportEagerDependency = require("./ImportEagerDependency");
-const { ImportPhaseUtils, createGetImportPhase } = require("./ImportPhase");
+const { createGetImportPhase } = require("./ImportPhase");
 const ImportWeakDependency = require("./ImportWeakDependency");
 
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
@@ -262,11 +262,14 @@ class ImportParserPlugin {
 		parser.hooks.importCall.tap(PLUGIN_NAME, (expr, importThen) => {
 			const param = parser.evaluateExpression(expr.source);
 
+			/** @type {null | string} */
 			let chunkName = null;
 			let mode = /** @type {ContextMode} */ (this.options.dynamicImportMode);
+			/** @type {null | RegExp} */
 			let include = null;
+			/** @type {null | RegExp} */
 			let exclude = null;
-			/** @type {RawReferencedExports | null} */
+			/** @type {null | RawReferencedExports} */
 			let exports = null;
 			/** @type {RawChunkGroupOptions} */
 			const groupOptions = {};
@@ -557,15 +560,6 @@ class ImportParserPlugin {
 					mode = "async-weak";
 				}
 
-				if (ImportPhaseUtils.isDefer(phase)) {
-					parser.state.module.addWarning(
-						new UnsupportedFeatureWarning(
-							"import.defer() is not yet supported for ContextModule (the import path is a dynamic expression).",
-							/** @type {DependencyLocation} */ (expr.loc)
-						)
-					);
-				}
-
 				const dep = ContextDependencyHelpers.create(
 					ImportContextDependency,
 					/** @type {Range} */ (expr.range),
@@ -586,7 +580,8 @@ class ImportParserPlugin {
 						typePrefix: "import()",
 						category: "esm",
 						referencedExports: exports,
-						attributes: getImportAttributes(expr)
+						attributes: getImportAttributes(expr),
+						phase
 					},
 					parser
 				);

package/lib/dependencies/LoaderPlugin.js

@@ -10,6 +10,7 @@ const LazySet = require("../util/LazySet");
 const LoaderDependency = require("./LoaderDependency");
 const LoaderImportDependency = require("./LoaderImportDependency");
 
+/** @typedef {import("webpack-sources").RawSourceMap} RawSourceMap */
 /** @typedef {import("../Compilation").DependencyConstructor} DependencyConstructor */
 /** @typedef {import("../Compilation").ExecuteModuleExports} ExecuteModuleExports */
 /** @typedef {import("../Compilation").ExecuteModuleResult} ExecuteModuleResult */
@@ -116,7 +117,9 @@ class LoaderPlugin {
 										)
 									);
 								}
+								/** @type {null | RawSourceMap} */
 								let map;
+								/** @type {string | Buffer | undefined} */
 								let source;
 								if (moduleSource.sourceAndMap) {
 									const sourceAndMap = moduleSource.sourceAndMap();

package/lib/dependencies/ModuleDecoratorDependency.js

@@ -30,6 +30,7 @@ class ModuleDecoratorDependency extends NullDependency {
 		super();
 		this.decorator = decorator;
 		this.allowExportsAccess = allowExportsAccess;
+		/** @type {undefined | string} */
 		this._hashUpdate = undefined;
 	}
 

package/lib/dependencies/ModuleDependency.js

@@ -27,6 +27,7 @@ class ModuleDependency extends Dependency {
 		this.sourceOrder = sourceOrder;
 		/** @type {Range | undefined} */
 		this.range = undefined;
+		/** @type {undefined | string} */
 		this._context = undefined;
 	}
 

package/lib/dependencies/ModuleInitFragmentDependency.js

@@ -0,0 +1,87 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Natsu @xiaoxiaojx
+*/
+
+"use strict";
+
+const InitFragment = require("../InitFragment");
+const makeSerializable = require("../util/makeSerializable");
+const NullDependency = require("./NullDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/**
+ * A dependency that adds an init fragment to the module
+ */
+class ModuleInitFragmentDependency extends NullDependency {
+	/**
+	 * @param {string} initCode the initialization code
+	 * @param {string[]} runtimeRequirements runtime requirements
+	 * @param {string=} key unique key to avoid emitting the same initialization code twice
+	 */
+	constructor(initCode, runtimeRequirements, key) {
+		super();
+		this.initCode = initCode;
+		this.runtimeRequirements = runtimeRequirements;
+		this.key = key;
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.initCode);
+		write(this.runtimeRequirements);
+		write(this.key);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.initCode = read();
+		this.runtimeRequirements = read();
+		this.key = read();
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	ModuleInitFragmentDependency,
+	"webpack/lib/dependencies/ModuleInitFragmentDependency"
+);
+
+ModuleInitFragmentDependency.Template = class ModuleInitFragmentDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, { initFragments, runtimeRequirements }) {
+		const dep = /** @type {ModuleInitFragmentDependency} */ (dependency);
+		for (const req of dep.runtimeRequirements) {
+			runtimeRequirements.add(req);
+		}
+		initFragments.push(
+			new InitFragment(
+				dep.initCode,
+				InitFragment.STAGE_CONSTANTS,
+				0,
+				dep.key,
+				undefined
+			)
+		);
+	}
+};
+
+module.exports = ModuleInitFragmentDependency;

package/lib/dependencies/ProvidedDependency.js

@@ -44,6 +44,7 @@ class ProvidedDependency extends ModuleDependency {
 		this.identifier = identifier;
 		this.ids = ids;
 		this.range = range;
+		/** @type {undefined | string} */
 		this._hashUpdate = undefined;
 	}
 

package/lib/dependencies/RequireContextPlugin.js

@@ -86,6 +86,7 @@ class RequireContextPlugin {
 							)
 						).options;
 
+						/** @type {{ context: string, request: string }[]} */
 						let newItems;
 						if (!finalResolveOptions.fullySpecified) {
 							newItems = [];

package/lib/dependencies/RequireEnsureDependenciesBlockParserPlugin.js

@@ -10,11 +10,14 @@ const RequireEnsureDependency = require("./RequireEnsureDependency");
 const RequireEnsureItemDependency = require("./RequireEnsureItemDependency");
 const getFunctionExpression = require("./getFunctionExpression");
 
+/** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").SpreadElement} SpreadElement */
 /** @typedef {import("../AsyncDependenciesBlock").GroupOptions} GroupOptions */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("./getFunctionExpression").FunctionExpressionResult} FunctionExpressionResult */
 
 const PLUGIN_NAME = "RequireEnsureDependenciesBlockParserPlugin";
 
@@ -27,8 +30,10 @@ module.exports = class RequireEnsureDependenciesBlockParserPlugin {
 		parser.hooks.call.for("require.ensure").tap(PLUGIN_NAME, (expr) => {
 			/** @type {string | GroupOptions | null} */
 			let chunkName = null;
-			let errorExpressionArg = null;
-			let errorExpression = null;
+			/** @type {undefined | Expression | SpreadElement} */
+			let errorExpressionArg;
+			/** @type {undefined | FunctionExpressionResult} */
+			let errorExpression;
 			switch (expr.arguments.length) {
 				case 4: {
 					const chunkNameExpr = parser.evaluateExpression(expr.arguments[3]);

package/lib/dependencies/RuntimeRequirementsDependency.js

@@ -24,6 +24,7 @@ class RuntimeRequirementsDependency extends NullDependency {
 	constructor(runtimeRequirements) {
 		super();
 		this.runtimeRequirements = new Set(runtimeRequirements);
+		/** @type {undefined | string} */
 		this._hashUpdate = undefined;
 	}
 

package/lib/dependencies/WorkerDependency.js

@@ -23,20 +23,26 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
+/**
+ * @typedef {object} WorkerDependencyOptions
+ * @property {string=} publicPath public path for the worker
+ * @property {boolean=} needNewUrl true when need generate `new URL(...)`, otherwise false
+ */
+
 class WorkerDependency extends ModuleDependency {
 	/**
 	 * @param {string} request request
 	 * @param {Range} range range
-	 * @param {object} workerDependencyOptions options
-	 * @param {string=} workerDependencyOptions.publicPath public path for the worker
-	 * @param {boolean=} workerDependencyOptions.needNewUrl need generate `new URL(...)`
+	 * @param {WorkerDependencyOptions} workerDependencyOptions options
 	 */
 	constructor(request, range, workerDependencyOptions) {
 		super(request);
 		this.range = range;
 		// If options are updated, don't forget to update the hash and serialization functions
+		/** @type {WorkerDependencyOptions} */
 		this.options = workerDependencyOptions;
 		/** Cache the hash */
+		/** @type {undefined | string} */
 		this._hashUpdate = undefined;
 	}
 

package/lib/dependencies/WorkerPlugin.js

@@ -387,6 +387,7 @@ class WorkerPlugin {
 
 						const block = new AsyncDependenciesBlock({
 							name: entryOptions.name,
+							circular: false,
 							entryOptions: {
 								chunkLoading: this._chunkLoading,
 								wasmLoading: this._wasmLoading,

package/lib/dependencies/getFunctionExpression.js

@@ -10,9 +10,11 @@
 /** @typedef {import("estree").FunctionExpression} FunctionExpression */
 /** @typedef {import("estree").SpreadElement} SpreadElement */
 
+/** @typedef {{ fn: FunctionExpression | ArrowFunctionExpression, expressions: (Expression | SpreadElement)[], needThis: boolean | undefined }} FunctionExpressionResult */
+
 /**
  * @param {Expression | SpreadElement} expr expressions
- * @returns {{ fn: FunctionExpression | ArrowFunctionExpression, expressions: (Expression | SpreadElement)[], needThis: boolean | undefined } | undefined} function expression with additional information
+ * @returns {FunctionExpressionResult | undefined} function expression with additional information
  */
 module.exports = (expr) => {
 	// <FunctionExpression>

package/lib/errors/BuildCycleError.js

@@ -11,7 +11,7 @@ const WebpackError = require("../WebpackError");
 
 class BuildCycleError extends WebpackError {
 	/**
-	 * Creates an instance of ModuleDependencyError.
+	 * Creates an instance of BuildCycleError.
 	 * @param {Module} module the module starting the cycle
 	 */
 	constructor(module) {
@@ -19,9 +19,12 @@ class BuildCycleError extends WebpackError {
 			"There is a circular build dependency, which makes it impossible to create this module"
 		);
 
+		/** @type {string} */
 		this.name = "BuildCycleError";
+		/** @type {Module} */
 		this.module = module;
 	}
 }
 
+/** @type {typeof BuildCycleError} */
 module.exports = BuildCycleError;

package/lib/esm/ModuleChunkFormatPlugin.js

@@ -212,6 +212,7 @@ class ModuleChunkFormatPlugin {
 						)}\n`
 					);
 
+					/** @type {Set<Chunk>} */
 					const loadedChunks = new Set();
 					for (let i = 0; i < entries.length; i++) {
 						const [module, entrypoint] = entries[i];
@@ -225,13 +226,14 @@ class ModuleChunkFormatPlugin {
 							/** @type {Chunk} */ (runtimeChunk),
 							undefined
 						);
+						/** @type {Set<Chunk>} */
 						const processChunks = new Set();
-						for (const _chunk of chunks) {
-							if (loadedChunks.has(_chunk)) {
+						for (const chunk of chunks) {
+							if (loadedChunks.has(chunk)) {
 								continue;
 							}
-							loadedChunks.add(_chunk);
-							processChunks.add(_chunk);
+							loadedChunks.add(chunk);
+							processChunks.add(chunk);
 						}
 						const sourceWithDependentChunks = withDependentChunks(
 							processChunks,

package/lib/esm/ModuleChunkLoadingPlugin.js

@@ -36,6 +36,7 @@ class ModuleChunkLoadingPlugin {
 						: globalChunkLoading;
 				return chunkLoading === "import";
 			};
+			/** @type {WeakSet<Chunk>} */
 			const onceForChunkSet = new WeakSet();
 			/**
 			 * @param {Chunk} chunk chunk to check

package/lib/esm/ModuleChunkLoadingRuntimeModule.js

@@ -60,6 +60,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 	 */
 	constructor(runtimeRequirements) {
 		super("import chunk loading", RuntimeModule.STAGE_ATTACH);
+		/** @type {ReadOnlyRuntimeRequirements} */
 		this._runtimeRequirements = runtimeRequirements;
 	}
 

package/lib/hmr/LazyCompilationPlugin.js

@@ -33,6 +33,8 @@ const { registerNotSerializable } = require("../util/serialization");
 /** @typedef {import("../Module").NeedBuildCallback} NeedBuildCallback */
 /** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
+/** @typedef {import("../Module").Sources} Sources */
+/** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
 /** @typedef {import("../ModuleFactory").ModuleFactoryCallback} ModuleFactoryCallback */
 /** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
 /** @typedef {import("../RequestShortener")} RequestShortener */
@@ -225,7 +227,9 @@ class LazyCompilationProxyModule extends Module {
 	 * @returns {CodeGenerationResult} result
 	 */
 	codeGeneration({ runtimeTemplate, chunkGraph, moduleGraph }) {
+		/** @type {Sources} */
 		const sources = new Map();
+		/** @type {RuntimeRequirements} */
 		const runtimeRequirements = new Set();
 		runtimeRequirements.add(RuntimeGlobals.module);
 		const clientDep = /** @type {CommonJsRequireDependency} */ (
@@ -247,6 +251,7 @@ class LazyCompilationProxyModule extends Module {
 				Boolean(block)
 			)}, module: module, onError: onError });`
 		]);
+		/** @type {string} */
 		let source;
 		if (block) {
 			const dep = block.dependencies[0];

package/lib/hmr/lazyCompilationBackend.js

@@ -19,11 +19,12 @@
 /** @typedef {() => Server} CreateServerFunction */
 
 /**
- * @param {Omit<LazyCompilationDefaultBackendOptions, "client"> & { client: NonNullable<LazyCompilationDefaultBackendOptions["client"]>}} options additional options for the backend
+ * @param {Omit<LazyCompilationDefaultBackendOptions, "client"> & { client: NonNullable<LazyCompilationDefaultBackendOptions["client"]> }} options additional options for the backend
  * @returns {BackendHandler} backend
  */
 module.exports = (options) => (compiler, callback) => {
 	const logger = compiler.getInfrastructureLogger("LazyCompilationBackend");
+	/** @type {Map<string, number>} */
 	const activeModules = new Map();
 	const prefix = "/lazy-compilation-using-";
 
@@ -152,7 +153,7 @@ module.exports = (options) => (compiler, callback) => {
 					const key = `${encodeURIComponent(
 						originalModule.identifier().replace(/\\/g, "/").replace(/@/g, "_")
 					).replace(/%(2F|3A|24|26|2B|2C|3B|3D)/g, decodeURIComponent)}`;
-					const active = activeModules.get(key) > 0;
+					const active = /** @type {number} */ (activeModules.get(key)) > 0;
 					return {
 						client: `${options.client}?${encodeURIComponent(urlBase + prefix)}`,
 						data: key,

package/lib/ids/ChunkModuleIdRangePlugin.js

@@ -13,6 +13,7 @@ const {
 
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../ChunkGraph").ModuleComparator} ModuleComparator */
 
 /**
  * @typedef {object} ChunkModuleIdRangePluginOptions
@@ -56,6 +57,7 @@ class ChunkModuleIdRangePlugin {
 				/** @type {Module[]} */
 				let chunkModules;
 				if (options.order) {
+					/** @type {ModuleComparator} */
 					let cmpFn;
 					switch (options.order) {
 						case "index":

package/lib/ids/IdHelpers.js

@@ -13,14 +13,14 @@ const numberHash = require("../util/numberHash");
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Module")} Module */
-/** @typedef {typeof import("../util/Hash")} Hash */
+/** @typedef {import("../util/Hash").HashFunction} HashFunction */
 /** @typedef {import("../util/identifier").AssociatedObjectForCache} AssociatedObjectForCache */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 
 /**
  * @param {string} str string to hash
  * @param {number} len max length of the hash
- * @param {string | Hash} hashFunction hash function to use
+ * @param {HashFunction} hashFunction hash function to use
  * @returns {string} hash
  */
 const getHash = (str, len, hashFunction) => {
@@ -56,12 +56,12 @@ const avoidNumber = (str) => {
  * @returns {string} id representation
  */
 const requestToId = (request) =>
-	request.replace(/^(\.\.?\/)+/, "").replace(/(^[.-]|[^a-zA-Z0-9_-])+/g, "_");
+	request.replace(/^(\.\.?\/)+/, "").replace(/(^[.-]|[^a-z0-9_-])+/gi, "_");
 
 /**
  * @param {string} string the string
  * @param {string} delimiter separator for string and hash
- * @param {string | Hash} hashFunction hash function to use
+ * @param {HashFunction} hashFunction hash function to use
  * @returns {string} string with limited max length to 100 chars
  */
 const shortenLongString = (string, delimiter, hashFunction) => {
@@ -95,7 +95,7 @@ const getShortModuleName = (module, context, associatedObjectForCache) => {
  * @param {string} shortName the short name
  * @param {Module} module the module
  * @param {string} context context directory
- * @param {string | Hash} hashFunction hash function to use
+ * @param {HashFunction} hashFunction hash function to use
  * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} long module name
  */
@@ -124,7 +124,7 @@ const getFullModuleName = (module, context, associatedObjectForCache) =>
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @param {string} context context directory
  * @param {string} delimiter delimiter for names
- * @param {string | Hash} hashFunction hash function to use
+ * @param {HashFunction} hashFunction hash function to use
  * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} short chunk name
  */
@@ -152,7 +152,7 @@ const getShortChunkName = (
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @param {string} context context directory
  * @param {string} delimiter delimiter for names
- * @param {string | Hash} hashFunction hash function to use
+ * @param {HashFunction} hashFunction hash function to use
  * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} short chunk name
  */
@@ -231,7 +231,7 @@ const addToMapOfItems = (map, key, value) => {
  */
 const getUsedModuleIdsAndModules = (compilation, filter) => {
 	const chunkGraph = compilation.chunkGraph;
-
+	/** @type {Module[]} */
 	const modules = [];
 
 	/** @type {UsedModuleIds} */
@@ -402,6 +402,7 @@ const assignDeterministicIds = (
 
 	for (const item of items) {
 		const ident = getName(item);
+		/** @type {number} */
 		let id;
 		let i = salt;
 		do {
@@ -420,6 +421,7 @@ const assignAscendingModuleIds = (usedIds, modules, compilation) => {
 	const chunkGraph = compilation.chunkGraph;
 
 	let nextId = 0;
+	/** @type {(mod: Module) => void} */
 	let assignId;
 	if (usedIds.size > 0) {
 		/**