webpack 5.97.1 → 5.104.1

package/lib/ChunkGroup.js

@@ -8,9 +8,9 @@
 const util = require("util");
 const SortableSet = require("./util/SortableSet");
 const {
-	compareLocations,
 	compareChunks,
-	compareIterables
+	compareIterables,
+	compareLocations
 } = require("./util/comparators");
 
 /** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
@@ -21,8 +21,7 @@ const {
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 
-/** @typedef {{id: number}} HasId */
-/** @typedef {{module: Module | null, loc: DependencyLocation, request: string}} OriginRecord */
+/** @typedef {{ module: Module | null, loc: DependencyLocation, request: string }} OriginRecord */
 
 /**
  * @typedef {object} RawChunkGroupOptions
@@ -40,13 +39,13 @@ let debugId = 5000;
  * @param {SortableSet<T>} set set to convert to array.
  * @returns {T[]} the array format of existing set
  */
-const getArray = set => Array.from(set);
+const getArray = (set) => [...set];
 
 /**
  * A convenience method used to sort chunks based on their id's
  * @param {ChunkGroup} a first sorting comparator
  * @param {ChunkGroup} b second sorting comparator
- * @returns {1|0|-1} a sorting index to determine order
+ * @returns {1 | 0 | -1} a sorting index to determine order
  */
 const sortById = (a, b) => {
 	if (a.id < b.id) return -1;
@@ -57,7 +56,7 @@ const sortById = (a, b) => {
 /**
  * @param {OriginRecord} a the first comparator in sort
  * @param {OriginRecord} b the second comparator in sort
- * @returns {1|-1|0} returns sorting order as index
+ * @returns {1 | -1| 0} returns sorting order as index
  */
 const sortOrigin = (a, b) => {
 	const aIdent = a.module ? a.module.identifier() : "";
@@ -92,16 +91,19 @@ class ChunkGroup {
 		this.chunks = [];
 		/** @type {OriginRecord[]} */
 		this.origins = [];
+
+		/** @typedef {Map<Module, number>} OrderIndices */
+
 		/** Indices in top-down order */
 		/**
 		 * @private
-		 * @type {Map<Module, number>}
+		 * @type {OrderIndices}
 		 */
 		this._modulePreOrderIndices = new Map();
 		/** Indices in bottom-up order */
 		/**
 		 * @private
-		 * @type {Map<Module, number>}
+		 * @type {OrderIndices}
 		 */
 		this._modulePostOrderIndices = new Map();
 		/** @type {number | undefined} */
@@ -114,17 +116,23 @@ class ChunkGroup {
 	 * @returns {void}
 	 */
 	addOptions(options) {
-		for (const _key of Object.keys(options)) {
-			const key = /** @type {keyof ChunkGroupOptions} */ (_key);
+		for (const key of /** @type {(keyof ChunkGroupOptions)[]} */ (
+			Object.keys(options)
+		)) {
 			if (this.options[key] === undefined) {
-				/** @type {TODO} */
-				(this.options)[key] = options[key];
+				/** @type {ChunkGroupOptions[keyof ChunkGroupOptions]} */
+				(this.options[key]) = options[key];
 			} else if (this.options[key] !== options[key]) {
 				if (key.endsWith("Order")) {
-					/** @type {TODO} */
-					(this.options)[key] = Math.max(
-						/** @type {number} */ (this.options[key]),
-						/** @type {number} */ (options[key])
+					const orderKey =
+						/** @type {Exclude<keyof ChunkGroupOptions, "name" | "fetchPriority">} */
+						(key);
+
+					this.options[orderKey] = Math.max(
+						/** @type {number} */
+						(this.options[orderKey]),
+						/** @type {number} */
+						(options[orderKey])
 					);
 				} else {
 					throw new Error(
@@ -137,7 +145,7 @@ class ChunkGroup {
 
 	/**
 	 * returns the name of current ChunkGroup
-	 * @returns {string | null | undefined} returns the ChunkGroup name
+	 * @returns {ChunkGroupOptions["name"]} returns the ChunkGroup name
 	 */
 	get name() {
 		return this.options.name;
@@ -158,7 +166,7 @@ class ChunkGroup {
 	 * @returns {string} a unique concatenation of chunk debugId's
 	 */
 	get debugId() {
-		return Array.from(this.chunks, x => x.debugId).join("+");
+		return Array.from(this.chunks, (x) => x.debugId).join("+");
 	}
 
 	/**
@@ -166,7 +174,7 @@ class ChunkGroup {
 	 * @returns {string} a unique concatenation of chunk ids
 	 */
 	get id() {
-		return Array.from(this.chunks, x => x.id).join("+");
+		return Array.from(this.chunks, (x) => x.id).join("+");
 	}
 
 	/**
@@ -366,7 +374,7 @@ class ChunkGroup {
 	}
 
 	/**
-	 * @returns {Array<AsyncDependenciesBlock>} an array containing the blocks
+	 * @returns {AsyncDependenciesBlock[]} an array containing the blocks
 	 */
 	getBlocks() {
 		return this._blocks.getFromCache(getArray);
@@ -429,7 +437,7 @@ class ChunkGroup {
 			}
 		}
 
-		return Array.from(files);
+		return [...files];
 	}
 
 	/**
@@ -480,7 +488,7 @@ class ChunkGroup {
 	 * Sorting values are based off of number of chunks in ChunkGroup.
 	 * @param {ChunkGraph} chunkGraph the chunk graph
 	 * @param {ChunkGroup} otherGroup the chunkGroup to compare this against
-	 * @returns {-1|0|1} sort position for comparison
+	 * @returns {-1 | 0 | 1} sort position for comparison
 	 */
 	compareTo(chunkGraph, otherGroup) {
 		if (this.chunks.length > otherGroup.chunks.length) return -1;
@@ -526,7 +534,7 @@ class ChunkGroup {
 				if (cmp !== 0) return cmp;
 				return a.group.compareTo(chunkGraph, b.group);
 			});
-			result[name] = list.map(i => i.group);
+			result[name] = list.map((i) => i.group);
 		}
 		return result;
 	}

package/lib/ChunkTemplate.js

@@ -9,7 +9,7 @@ const util = require("util");
 const memoize = require("./util/memoize");
 
 /** @typedef {import("tapable").Tap} Tap */
-/** @typedef {import("../declarations/WebpackOptions").Output} OutputOptions */
+/** @typedef {import("./config/defaults").OutputNormalizedWithDefaults} OutputOptions */
 /** @typedef {import("./Chunk")} Chunk */
 /** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./Compilation").ChunkHashContext} ChunkHashContext */
@@ -42,7 +42,7 @@ class ChunkTemplate {
 					/**
 					 * @template AdditionalOptions
 					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
-					 * @param {function(RenderManifestEntry[], RenderManifestOptions): RenderManifestEntry[]} fn function
+					 * @param {(renderManifestEntries: RenderManifestEntry[], renderManifestOptions: RenderManifestOptions) => RenderManifestEntry[]} fn function
 					 */
 					(options, fn) => {
 						compilation.hooks.renderManifest.tap(
@@ -62,7 +62,7 @@ class ChunkTemplate {
 					/**
 					 * @template AdditionalOptions
 					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
-					 * @param {function(Source, ModuleTemplate, RenderContext): Source} fn function
+					 * @param {(source: Source, moduleTemplate: ModuleTemplate, renderContext: RenderContext) => Source} fn function
 					 */
 					(options, fn) => {
 						getJavascriptModulesPlugin()
@@ -84,7 +84,7 @@ class ChunkTemplate {
 					/**
 					 * @template AdditionalOptions
 					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
-					 * @param {function(Source, ModuleTemplate, RenderContext): Source} fn function
+					 * @param {(source: Source, moduleTemplate: ModuleTemplate, renderContext: RenderContext) => Source} fn function
 					 */
 					(options, fn) => {
 						getJavascriptModulesPlugin()
@@ -106,7 +106,7 @@ class ChunkTemplate {
 					/**
 					 * @template AdditionalOptions
 					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
-					 * @param {function(Source, Chunk): Source} fn function
+					 * @param {(source: Source, chunk: Chunk) => Source} fn function
 					 */
 					(options, fn) => {
 						getJavascriptModulesPlugin()
@@ -132,7 +132,7 @@ class ChunkTemplate {
 					/**
 					 * @template AdditionalOptions
 					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
-					 * @param {function(Hash): void} fn function
+					 * @param {(hash: Hash) => void} fn function
 					 */
 					(options, fn) => {
 						compilation.hooks.fullHash.tap(options, fn);
@@ -146,7 +146,7 @@ class ChunkTemplate {
 					/**
 					 * @template AdditionalOptions
 					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
-					 * @param {function(Hash, Chunk, ChunkHashContext): void} fn function
+					 * @param {(hash: Hash, chunk: Chunk, chunkHashContext: ChunkHashContext) => void} fn function
 					 */
 					(options, fn) => {
 						getJavascriptModulesPlugin()
@@ -170,7 +170,7 @@ Object.defineProperty(ChunkTemplate.prototype, "outputOptions", {
 		 * @this {ChunkTemplate}
 		 * @returns {OutputOptions} output options
 		 */
-		function () {
+		function outputOptions() {
 			return this._outputOptions;
 		},
 		"ChunkTemplate.outputOptions is deprecated (use Compilation.outputOptions instead)",

package/lib/CleanPlugin.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const path = require("path");
 const asyncLib = require("neo-async");
 const { SyncBailHook } = require("tapable");
 const Compilation = require("./Compilation");
@@ -19,9 +20,7 @@ const processAsyncTree = require("./util/processAsyncTree");
 /** @typedef {import("./util/fs").OutputFileSystem} OutputFileSystem */
 /** @typedef {import("./util/fs").StatsCallback} StatsCallback */
 
-/** @typedef {(function(string):boolean)|RegExp} IgnoreItem */
 /** @typedef {Map<string, number>} Assets */
-/** @typedef {function(IgnoreItem): void} AddToIgnoreCallback */
 
 /**
  * @typedef {object} CleanPluginCompilationHooks
@@ -31,13 +30,14 @@ const processAsyncTree = require("./util/processAsyncTree");
 /**
  * @callback KeepFn
  * @param {string} path path
- * @returns {boolean | void} true, if the path should be kept
+ * @returns {boolean | undefined} true, if the path should be kept
  */
 
 const validate = createSchemaValidation(
 	undefined,
 	() => {
 		const { definitions } = require("../schemas/WebpackOptions.json");
+
 		return {
 			definitions,
 			oneOf: [{ $ref: "#/definitions/CleanOptions" }]
@@ -51,7 +51,7 @@ const validate = createSchemaValidation(
 const _10sec = 10 * 1000;
 
 /**
- * marge assets map 2 into map 1
+ * merge assets map 2 into map 1
  * @param {Assets} as1 assets
  * @param {Assets} as2 assets
  * @returns {void}
@@ -63,23 +63,44 @@ const mergeAssets = (as1, as2) => {
 	}
 };
 
+/** @typedef {Map<string, number>} CurrentAssets */
+
 /**
- * @param {OutputFileSystem} fs filesystem
- * @param {string} outputPath output path
- * @param {Map<string, number>} currentAssets filename of the current assets (must not start with .. or ., must only use / as path separator)
- * @param {function((Error | null)=, Set<string>=): void} callback returns the filenames of the assets that shouldn't be there
- * @returns {void}
+ * @param {CurrentAssets} assets current assets
+ * @returns {Set<string>} Set of directory paths
  */
-const getDiffToFs = (fs, outputPath, currentAssets, callback) => {
+function getDirectories(assets) {
 	const directories = new Set();
+	/**
+	 * @param {string} filename asset filename
+	 */
+	const addDirectory = (filename) => {
+		directories.add(path.dirname(filename));
+	};
+
 	// get directories of assets
-	for (const [asset] of currentAssets) {
-		directories.add(asset.replace(/(^|\/)[^/]*$/, ""));
+	for (const [asset] of assets) {
+		addDirectory(asset);
 	}
 	// and all parent directories
 	for (const directory of directories) {
-		directories.add(directory.replace(/(^|\/)[^/]*$/, ""));
+		addDirectory(directory);
 	}
+	return directories;
+}
+
+/** @typedef {Set<string>} Diff */
+
+/**
+ * @param {OutputFileSystem} fs filesystem
+ * @param {string} outputPath output path
+ * @param {CurrentAssets} currentAssets filename of the current assets (must not start with .. or ., must only use / as path separator)
+ * @param {(err?: Error | null, set?: Diff) => void} callback returns the filenames of the assets that shouldn't be there
+ * @returns {void}
+ */
+const getDiffToFs = (fs, outputPath, currentAssets, callback) => {
+	const directories = getDirectories(currentAssets);
+	/** @type {Diff} */
 	const diff = new Set();
 	asyncLib.forEachLimit(
 		directories,
@@ -97,7 +118,10 @@ const getDiffToFs = (fs, outputPath, currentAssets, callback) => {
 				}
 				for (const entry of /** @type {string[]} */ (entries)) {
 					const file = entry;
-					const filename = directory ? `${directory}/${file}` : file;
+					// Since path.normalize("./file") === path.normalize("file"),
+					// return file directly when directory === "."
+					const filename =
+						directory && directory !== "." ? `${directory}/${file}` : file;
 					if (!directories.has(filename) && !currentAssets.has(filename)) {
 						diff.add(filename);
 					}
@@ -105,7 +129,7 @@ const getDiffToFs = (fs, outputPath, currentAssets, callback) => {
 				callback();
 			});
 		},
-		err => {
+		(err) => {
 			if (err) return callback(err);
 
 			callback(null, diff);
@@ -116,7 +140,7 @@ const getDiffToFs = (fs, outputPath, currentAssets, callback) => {
 /**
  * @param {Assets} currentAssets assets list
  * @param {Assets} oldAssets old assets list
- * @returns {Set<string>} diff
+ * @returns {Diff} diff
  */
 const getDiffToOldAssets = (currentAssets, oldAssets) => {
 	const diff = new Set();
@@ -148,16 +172,16 @@ const doStat = (fs, filename, callback) => {
  * @param {string} outputPath output path
  * @param {boolean} dry only log instead of fs modification
  * @param {Logger} logger logger
- * @param {Set<string>} diff filenames of the assets that shouldn't be there
- * @param {function(string): boolean | void} isKept check if the entry is ignored
- * @param {function(Error=, Assets=): void} callback callback
+ * @param {Diff} diff filenames of the assets that shouldn't be there
+ * @param {KeepFn} isKept check if the entry is ignored
+ * @param {(err?: Error, assets?: Assets) => void} callback callback
  * @returns {void}
  */
 const applyDiff = (fs, outputPath, dry, logger, diff, isKept, callback) => {
 	/**
 	 * @param {string} msg message
 	 */
-	const log = msg => {
+	const log = (msg) => {
 		if (dry) {
 			logger.info(msg);
 		} else {
@@ -166,7 +190,7 @@ const applyDiff = (fs, outputPath, dry, logger, diff, isKept, callback) => {
 	};
 	/** @typedef {{ type: "check" | "unlink" | "rmdir", filename: string, parent: { remaining: number, job: Job } | undefined }} Job */
 	/** @type {Job[]} */
-	const jobs = Array.from(diff.keys(), filename => ({
+	const jobs = Array.from(diff.keys(), (filename) => ({
 		type: "check",
 		filename,
 		parent: undefined
@@ -177,22 +201,43 @@ const applyDiff = (fs, outputPath, dry, logger, diff, isKept, callback) => {
 		jobs,
 		10,
 		({ type, filename, parent }, push, callback) => {
+			const path = join(fs, outputPath, filename);
 			/**
 			 * @param {Error & { code?: string }} err error
 			 * @returns {void}
 			 */
-			const handleError = err => {
-				if (err.code === "ENOENT") {
-					log(`${filename} was removed during cleaning by something else`);
-					handleParent();
-					return callback();
-				}
-				return callback(err);
+			const handleError = (err) => {
+				const isAlreadyRemoved = () =>
+					new Promise((resolve) => {
+						if (err.code === "ENOENT") {
+							resolve(true);
+						} else if (err.code === "EPERM") {
+							// https://github.com/isaacs/rimraf/blob/main/src/fix-eperm.ts#L37
+							// fs.existsSync(path) === false https://github.com/webpack/webpack/actions/runs/15493412975/job/43624272783?pr=19586
+							doStat(fs, path, (err) => {
+								if (err) {
+									resolve(err.code === "ENOENT");
+								} else {
+									resolve(false);
+								}
+							});
+						} else {
+							resolve(false);
+						}
+					});
+
+				isAlreadyRemoved().then((isRemoved) => {
+					if (isRemoved) {
+						log(`${filename} was removed during cleaning by something else`);
+						handleParent();
+						return callback();
+					}
+					return callback(err);
+				});
 			};
 			const handleParent = () => {
 				if (parent && --parent.remaining === 0) push(parent.job);
 			};
-			const path = join(fs, outputPath, filename);
 			switch (type) {
 				case "check":
 					if (isKept(filename)) {
@@ -260,7 +305,7 @@ const applyDiff = (fs, outputPath, dry, logger, diff, isKept, callback) => {
 						);
 						return process.nextTick(callback);
 					}
-					fs.rmdir(path, err => {
+					fs.rmdir(path, (err) => {
 						if (err) return handleError(err);
 						handleParent();
 						callback();
@@ -278,7 +323,7 @@ const applyDiff = (fs, outputPath, dry, logger, diff, isKept, callback) => {
 						);
 						return process.nextTick(callback);
 					}
-					fs.unlink(path, err => {
+					fs.unlink(path, (err) => {
 						if (err) return handleError(err);
 						handleParent();
 						callback();
@@ -286,7 +331,7 @@ const applyDiff = (fs, outputPath, dry, logger, diff, isKept, callback) => {
 					break;
 			}
 		},
-		err => {
+		(err) => {
 			if (err) return callback(err);
 			callback(undefined, keptAssets);
 		}
@@ -296,6 +341,8 @@ const applyDiff = (fs, outputPath, dry, logger, diff, isKept, callback) => {
 /** @type {WeakMap<Compilation, CleanPluginCompilationHooks>} */
 const compilationHooksMap = new WeakMap();
 
+const PLUGIN_NAME = "CleanPlugin";
+
 class CleanPlugin {
 	/**
 	 * @param {Compilation} compilation the compilation
@@ -336,31 +383,31 @@ class CleanPlugin {
 			typeof keep === "function"
 				? keep
 				: typeof keep === "string"
-					? path => path.startsWith(keep)
+					? (path) => path.startsWith(keep)
 					: typeof keep === "object" && keep.test
-						? path => keep.test(path)
+						? (path) => keep.test(path)
 						: () => false;
 
 		// We assume that no external modification happens while the compiler is active
 		// So we can store the old assets and only diff to them to avoid fs access on
 		// incremental builds
-		/** @type {undefined|Assets} */
+		/** @type {undefined | Assets} */
 		let oldAssets;
 
 		compiler.hooks.emit.tapAsync(
 			{
-				name: "CleanPlugin",
+				name: PLUGIN_NAME,
 				stage: 100
 			},
 			(compilation, callback) => {
 				const hooks = CleanPlugin.getCompilationHooks(compilation);
-				const logger = compilation.getLogger("webpack.CleanPlugin");
+				const logger = compilation.getLogger(`webpack.${PLUGIN_NAME}`);
 				const fs = /** @type {OutputFileSystem} */ (compiler.outputFileSystem);
 
 				if (!fs.readdir) {
 					return callback(
 						new Error(
-							"CleanPlugin: Output filesystem doesn't support listing directories (readdir)"
+							`${PLUGIN_NAME}: Output filesystem doesn't support listing directories (readdir)`
 						)
 					);
 				}
@@ -392,9 +439,9 @@ class CleanPlugin {
 
 				/**
 				 * @param {string} path path
-				 * @returns {boolean | void} true, if needs to be kept
+				 * @returns {boolean | undefined} true, if needs to be kept
 				 */
-				const isKept = path => {
+				const isKept = (path) => {
 					const result = hooks.keep.call(path);
 					if (result !== undefined) return result;
 					return keepFn(path);
@@ -402,7 +449,7 @@ class CleanPlugin {
 
 				/**
 				 * @param {(Error | null)=} err err
-				 * @param {Set<string>=} diff diff
+				 * @param {Diff=} diff diff
 				 */
 				const diffCallback = (err, diff) => {
 					if (err) {
@@ -415,7 +462,7 @@ class CleanPlugin {
 						outputPath,
 						dry,
 						logger,
-						/** @type {Set<string>} */ (diff),
+						/** @type {Diff} */ (diff),
 						isKept,
 						(err, keptAssets) => {
 							if (err) {
@@ -441,3 +488,4 @@ class CleanPlugin {
 }
 
 module.exports = CleanPlugin;
+module.exports._getDirectories = getDirectories;

package/lib/CodeGenerationResults.js

@@ -5,14 +5,17 @@
 
 "use strict";
 
+const { DEFAULTS } = require("./config/defaults");
 const { getOrInsert } = require("./util/MapHelpers");
 const { first } = require("./util/SetHelpers");
 const createHash = require("./util/createHash");
-const { runtimeToString, RuntimeSpecMap } = require("./util/runtime");
+const { RuntimeSpecMap, runtimeToString } = require("./util/runtime");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("./Module")} Module */
+/** @typedef {import("./Module").SourceType} SourceType */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("./Module").CodeGenerationResultData} CodeGenerationResultData */
 /** @typedef {import("./Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
 /** @typedef {typeof import("./util/Hash")} Hash */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
@@ -21,7 +24,7 @@ class CodeGenerationResults {
 	/**
 	 * @param {string | Hash} hashFunction the hash function to use
 	 */
-	constructor(hashFunction = "md4") {
+	constructor(hashFunction = DEFAULTS.HASH_FUNCTION) {
 		/** @type {Map<Module, RuntimeSpecMap<CodeGenerationResult>>} */
 		this.map = new Map();
 		this._hashFunction = hashFunction;
@@ -38,7 +41,7 @@ class CodeGenerationResults {
 			throw new Error(
 				`No code generation entry for ${module.identifier()} (existing entries: ${Array.from(
 					this.map.keys(),
-					m => m.identifier()
+					(m) => m.identifier()
 				).join(", ")})`
 			);
 		}
@@ -49,7 +52,7 @@ class CodeGenerationResults {
 					throw new Error(
 						`No unique code generation entry for unspecified runtime for ${module.identifier()} (existing runtimes: ${Array.from(
 							entry.keys(),
-							r => runtimeToString(r)
+							(r) => runtimeToString(r)
 						).join(", ")}).
 Caller might not support runtime-dependent code generation (opt-out via optimization.usedExports: "global").`
 					);
@@ -65,7 +68,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 					runtime
 				)} for ${module.identifier()} (existing runtimes: ${Array.from(
 					entry.keys(),
-					r => runtimeToString(r)
+					(r) => runtimeToString(r)
 				).join(", ")})`
 			);
 		}
@@ -94,7 +97,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 	/**
 	 * @param {Module} module the module
 	 * @param {RuntimeSpec} runtime runtime(s)
-	 * @param {string} sourceType the source type
+	 * @param {SourceType} sourceType the source type
 	 * @returns {Source} a source
 	 */
 	getSource(module, runtime, sourceType) {
@@ -116,7 +119,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 	 * @param {Module} module the module
 	 * @param {RuntimeSpec} runtime runtime(s)
 	 * @param {string} key data key
-	 * @returns {any} data generated by code generation
+	 * @returns {ReturnType<CodeGenerationResultData["get"]>} data generated by code generation
 	 */
 	getData(module, runtime, key) {
 		const data = this.get(module, runtime).data;
@@ -126,7 +129,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 	/**
 	 * @param {Module} module the module
 	 * @param {RuntimeSpec} runtime runtime(s)
-	 * @returns {any} hash of the code generation
+	 * @returns {string} hash of the code generation
 	 */
 	getHash(module, runtime) {
 		const info = this.get(module, runtime);
@@ -139,7 +142,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 		if (info.runtimeRequirements) {
 			for (const rr of info.runtimeRequirements) hash.update(rr);
 		}
-		return (info.hash = /** @type {string} */ (hash.digest("hex")));
+		return (info.hash = hash.digest("hex"));
 	}
 
 	/**