webpack 5.112.0 → 5.112.2

package/lib/module/extractSourceMap.js

@@ -20,15 +20,20 @@ const { isAbsolute, join } = require("../fs/fs");
  * @typedef {object} SourceMappingURL
  * @property {string} sourceMappingURL
  * @property {string} replacementString
+ * @property {number} replacementStart
  */
 
 // Matches only the last occurrence of sourceMappingURL
 const innerRegex = /\s*[#@]\s*sourceMappingURL\s*=\s*([^\s'"]*)\s*/;
 
 const validProtocolPattern = /^[a-z][a-z0-9+.-]*:/i;
+const whitespaceRegex = /\s/;
+const lineBreakRegex = /[\r\n\u2028\u2029]/;
+const ambiguousCommentRegex = /['"`]|\*\//;
+const ambiguousBlockCommentRegex = /['"`\]]|\*\/(?!$)/;
 
 const sourceMappingURLRegex = new RegExp(
-	"(?:" +
+	"^(?:" +
 		"/\\*" +
 		"(?:\\s*\r?\n(?://)?)?" +
 		`(?:${innerRegex.source})` +
@@ -37,7 +42,7 @@ const sourceMappingURLRegex = new RegExp(
 		"|" +
 		`//(?:${innerRegex.source})` +
 		")" +
-		"\\s*"
+		"\\s*$"
 );
 
 /**
@@ -46,24 +51,67 @@ const sourceMappingURLRegex = new RegExp(
  * @returns {SourceMappingURL} source mapping information
  */
 function getSourceMappingURL(code) {
-	const lines = code.split(/^/m);
-	/** @type {RegExpMatchArray | null | undefined} */
-	let match;
-
-	for (let i = lines.length - 1; i >= 0; i--) {
-		match = lines[i].match(sourceMappingURLRegex);
-		if (match) {
+	let end = code.length;
+	let lineStart = end;
+	// ECMA-426's non-parsing extraction stops at code or ambiguous comments.
+	// Block comments also support CSS and existing JavaScript annotations.
+	while (end > 0) {
+		while (end > 0 && whitespaceRegex.test(code[end - 1])) end--;
+		if (end === 0) break;
+		// Consecutive block comments can share a long line of generated code.
+		if (lineStart >= end) {
+			lineStart = end;
+			while (lineStart > 0 && !lineBreakRegex.test(code[lineStart - 1])) {
+				lineStart--;
+			}
+			while (lineStart < end && whitespaceRegex.test(code[lineStart])) {
+				lineStart++;
+			}
+		}
+		let start = lineStart;
+		let comment;
+		if (code.startsWith("//", start)) {
+			comment = code.slice(start, end);
+			if (ambiguousCommentRegex.test(comment)) break;
+		} else if (code.endsWith("*/", end)) {
+			start = code.lastIndexOf("/*", end - 2);
+			if (start < 0) break;
+			comment = code.slice(start, end);
+			// An escaped opener or a character class can belong to a trailing RegExp.
+			if (
+				code[start - 1] === "\\" ||
+				ambiguousBlockCommentRegex.test(comment)
+			) {
+				break;
+			}
+			// Comments cannot nest; an inner opener may only be comment text.
+			if (
+				start > 0 &&
+				code.lastIndexOf("/*", start - 1) > code.lastIndexOf("*/", start - 1)
+			) {
+				break;
+			}
+		} else {
 			break;
 		}
+		const match = sourceMappingURLRegex.exec(comment);
+		if (match) {
+			const sourceMappingURL = match[1] || match[2] || "";
+			return {
+				sourceMappingURL: sourceMappingURL
+					? decodeURI(sourceMappingURL)
+					: sourceMappingURL,
+				replacementString: comment,
+				replacementStart: start
+			};
+		}
+		end = start;
 	}
 
-	const sourceMappingURL = match ? match[1] || match[2] || "" : "";
-
 	return {
-		sourceMappingURL: sourceMappingURL
-			? decodeURI(sourceMappingURL)
-			: sourceMappingURL,
-		replacementString: match ? match[0] : ""
+		sourceMappingURL: "",
+		replacementString: "",
+		replacementStart: 0
 	};
 }
 
@@ -229,7 +277,8 @@ async function extractSourceMap(stringOrBuffer, resourcePath, readResource) {
 		source: stringOrBuffer,
 		sourceMap: inputSourceMap
 	};
-	const { sourceMappingURL, replacementString } = getSourceMappingURL(input);
+	const { sourceMappingURL, replacementString, replacementStart } =
+		getSourceMappingURL(input);
 
 	if (!sourceMappingURL) {
 		return output;
@@ -310,8 +359,10 @@ async function extractSourceMap(stringOrBuffer, resourcePath, readResource) {
 	}
 
 	return {
-		source: input.replace(replacementString, ""),
-		sourceMap: /** @type {RawSourceMap} */ (newMap)
+		source:
+			input.slice(0, replacementStart) +
+			input.slice(replacementStart + replacementString.length),
+		sourceMap: newMap
 	};
 }
 

package/lib/module/findCaseMismatch.js

@@ -68,7 +68,7 @@ const findCaseMismatch = (fs, missingPath, callback) => {
 		}
 		fs.readdir(next, (err, nextEntries) => {
 			if (err || !nextEntries) return callback();
-			walkDown(next, /** @type {string[]} */ (nextEntries), index + 1);
+			walkDown(next, nextEntries, index + 1);
 		});
 	};
 
@@ -89,7 +89,7 @@ const findCaseMismatch = (fs, missingPath, callback) => {
 				return walkUp();
 			}
 			segments.reverse();
-			walkDown(parent, /** @type {string[]} */ (entries), 0);
+			walkDown(parent, entries, 0);
 		});
 	};
 

package/lib/node/ExternalModuleInitFragment.js

@@ -9,7 +9,7 @@ const InitFragment = require("../template/InitFragment");
 const makeSerializable = require("../util/makeSerializable");
 
 /** @import { Source } from "webpack-sources" */
-/** @import { GenerateContext } from "../module/Generator" */
+/** @import { ChunkRenderContext as GenerateContext } from "../javascript/JavascriptModulesPlugin" */
 /** @typedef {{ name: string, value?: string }[]} ArrayImportSpecifiers */
 /** @typedef {Set<string>} ImportSpecifier */
 /** @typedef {Map<string, ImportSpecifier>} ImportSpecifiers */
@@ -81,7 +81,7 @@ class ExternalModuleInitFragment extends InitFragment {
 	 * @param {GenerateContext} context context
 	 * @returns {string | Source | undefined} the source code that will be included as initialization code
 	 */
-	getContent({ runtimeRequirements }) {
+	getContent(context) {
 		/** @type {string[]} */
 		const namedImports = [];
 

package/lib/node/ReadFileCompileAsyncWasmPlugin.js

@@ -154,9 +154,7 @@ class ReadFileCompileAsyncWasmPlugin {
 							chunk.runtime
 						) &&
 						needsRuntimeFullHash(
-							/** @type {string} */ (
-								compilation.outputOptions.webassemblyModuleFilename
-							)
+							compilation.outputOptions.webassemblyModuleFilename
 						)
 					) {
 						set.add(RuntimeGlobals.getFullHash);
@@ -165,9 +163,7 @@ class ReadFileCompileAsyncWasmPlugin {
 						chunk,
 						new AsyncWasmLoadingRuntimeModule({
 							fullHashDigest: usesFullHashDigest(
-								/** @type {string} */ (
-									compilation.outputOptions.webassemblyModuleFilename
-								)
+								compilation.outputOptions.webassemblyModuleFilename
 							),
 							generateLoadBinaryCode,
 							supportsStreaming: false
@@ -196,9 +192,7 @@ class ReadFileCompileAsyncWasmPlugin {
 							chunk.runtime
 						) &&
 						needsRuntimeFullHash(
-							/** @type {string} */ (
-								compilation.outputOptions.webassemblyModuleFilename
-							)
+							compilation.outputOptions.webassemblyModuleFilename
 						)
 					) {
 						set.add(RuntimeGlobals.getFullHash);
@@ -207,9 +201,7 @@ class ReadFileCompileAsyncWasmPlugin {
 						chunk,
 						new AsyncWasmCompileRuntimeModule({
 							fullHashDigest: usesFullHashDigest(
-								/** @type {string} */ (
-									compilation.outputOptions.webassemblyModuleFilename
-								)
+								compilation.outputOptions.webassemblyModuleFilename
 							),
 							generateLoadBinaryCode,
 							supportsStreaming: false

package/lib/node/ReadFileCompileWasmPlugin.js

@@ -137,9 +137,7 @@ class ReadFileCompileWasmPlugin {
 					set.add(RuntimeGlobals.moduleCache);
 					if (
 						needsRuntimeFullHash(
-							/** @type {string} */ (
-								compilation.outputOptions.webassemblyModuleFilename
-							)
+							compilation.outputOptions.webassemblyModuleFilename
 						)
 					) {
 						set.add(RuntimeGlobals.getFullHash);
@@ -148,9 +146,7 @@ class ReadFileCompileWasmPlugin {
 						chunk,
 						new WasmChunkLoadingRuntimeModule({
 							fullHashDigest: usesFullHashDigest(
-								/** @type {string} */ (
-									compilation.outputOptions.webassemblyModuleFilename
-								)
+								compilation.outputOptions.webassemblyModuleFilename
 							),
 							generateLoadBinaryCode,
 							supportsStreaming: false,

package/lib/node/nodeConsole.js

@@ -129,7 +129,8 @@ module.exports = ({ colors, appendOnly, stream, compiler }) => {
 	};
 
 	/**
-	 * @param {EXPECTED_ANY[]} statusMessage status message
+	 * @template T
+	 * @param {T[]} statusMessage status message
 	 * @returns {void}
 	 */
 	const setStatusMessage = (statusMessage) => {
@@ -155,10 +156,10 @@ module.exports = ({ colors, appendOnly, stream, compiler }) => {
 			writeStatusMessage();
 		};
 
-	/** @type {<T extends unknown[]>(...args: T) => void} */
+	/** @type {LoggerConsole["log"]} */
 	const writeGroupMessage = writeColored("<-> ", (str) => c.bold(c.cyan(str)));
 
-	/** @type {<T extends unknown[]>(...args: T) => void} */
+	/** @type {LoggerConsole["log"]} */
 	const writeGroupCollapsedMessage = writeColored("<+> ", (str) =>
 		c.bold(c.cyan(str))
 	);

package/lib/optimize/CircularModulesPlugin.js

@@ -357,7 +357,7 @@ class CircularModulesPlugin {
 	 * @returns {number | undefined} bit flags from CircularKind
 	 */
 	static getCircularKind(module) {
-		const buildInfo = /** @type {BuildInfo | undefined} */ (module.buildInfo);
+		const buildInfo = module.buildInfo;
 		if (!buildInfo || buildInfo.circularKind === undefined) return undefined;
 		return buildInfo.circularKind;
 	}

package/lib/optimize/ConcatenatedModule.js

@@ -1471,8 +1471,6 @@ class ConcatenatedModule extends Module {
 				if (runtimeCondition === false) continue;
 				const nonDeferAccess = !defer;
 				const module = connection.module;
-				if (targets === undefined) targets = [module];
-				else if (!targets.includes(module)) targets.push(module);
 				const dependency = connection.dependency;
 				if (
 					dependency !== null &&
@@ -1483,6 +1481,8 @@ class ConcatenatedModule extends Module {
 				}
 				const entry = referencesMap.get(module);
 				if (entry === undefined) {
+					if (targets === undefined) targets = [module];
+					else targets.push(module);
 					referencesMap.set(module, {
 						connection,
 						runtimeCondition,
@@ -2342,9 +2342,7 @@ class ConcatenatedModule extends Module {
 								newName &&
 								concatenatedModuleInfo.call(
 									{
-										rawExportMap: new Map([
-											[exportId, /** @type {string} */ (newName)]
-										])
+										rawExportMap: new Map([[exportId, newName]])
 									},
 									/** @type {ConcatenatedModuleInfo} */ (referencedInfo)
 								);
@@ -2820,9 +2818,7 @@ ${defineGetters}`
 				if (!info.wrapped) {
 					const source = namespaceObjectSources.get(info);
 					if (source) result.add(source);
-					const escapeSource = escapeNamespaceObjectSources.get(
-						/** @type {ConcatenatedModuleInfo} */ (info)
-					);
+					const escapeSource = escapeNamespaceObjectSources.get(info);
 					if (escapeSource) result.add(escapeSource);
 				}
 			} else if (info.type === "external" && info.deferred) {

package/lib/optimize/FlagDependencyExportsPlugin.js

@@ -39,7 +39,7 @@ const PLUGIN_LOGGER_NAME = `webpack.${PLUGIN_NAME}`;
  */
 const getProvidedExportsEtag = (module, lazyBarrels, hashFunction) => {
 	const lazyRequests = lazyBarrels.getLazyRequests(module);
-	const buildInfo = /** @type {BuildInfo | undefined} */ (module.buildInfo);
+	const buildInfo = module.buildInfo;
 	const valueDependencies = buildInfo && buildInfo.valueDependencies;
 	const hasValueDependencies =
 		valueDependencies !== undefined && valueDependencies.size > 0;
@@ -145,9 +145,8 @@ class FlagDependencyExportsPlugin {
 								exportsInfo.restoreProvided(memCacheEntry.data);
 								return callback();
 							}
-							const buildHash = /** @type {string} */ (
-								/** @type {BuildInfo} */ (module.buildInfo).hash
-							);
+							const buildHash = /** @type {BuildInfo} */ (module.buildInfo)
+								.hash;
 							cache.get(
 								module.identifier(),
 								etag ? `${buildHash}|${etag}` : buildHash,
@@ -391,10 +390,7 @@ class FlagDependencyExportsPlugin {
 											if (exports) {
 												const nestedExportsInfo =
 													exportInfo.createNestedExportsInfo();
-												mergeExports(
-													/** @type {ExportsInfo} */ (nestedExportsInfo),
-													exports
-												);
+												mergeExports(nestedExportsInfo, exports);
 											}
 
 											if (
@@ -545,9 +541,8 @@ class FlagDependencyExportsPlugin {
 										};
 										memCache.set(this, entry);
 									}
-									const buildHash = /** @type {string} */ (
-										/** @type {BuildInfo} */ (module.buildInfo).hash
-									);
+									const buildHash = /** @type {BuildInfo} */ (module.buildInfo)
+										.hash;
 									cache.store(
 										module.identifier(),
 										etag ? `${buildHash}|${etag}` : buildHash,

package/lib/optimize/FlagDependencyUsagePlugin.js

@@ -16,7 +16,7 @@ const TupleQueue = require("./TupleQueue");
 
 /** @import Compiler from "../Compiler" */
 /** @import DependenciesBlock from "../graph/DependenciesBlock" */
-/** @import { ReferencedExport, ReferencedExports } from "../graph/Dependency" */
+/** @import { ExportInfoName, ReferencedExport, ReferencedExports } from "../graph/Dependency" */
 /** @import ExportsInfo from "../graph/ExportsInfo" */
 /** @import Module from "../module/Module" */
 /** @import { RuntimeSpec } from "../util/runtime" */
@@ -77,6 +77,25 @@ class FlagDependencyUsagePlugin {
 					/** @type {Map<ExportsInfo, Module>} */
 					const exportInfoToModuleMap = new Map();
 
+					/**
+					 * Returns the module owning an export of a nested exports info. A
+					 * nested exports info redirecting to a module's exports owns only
+					 * its own names, the rest belong to the redirect target.
+					 * @param {ExportsInfo} exportsInfo nested exports info
+					 * @param {ExportInfoName} name export name
+					 * @returns {Module | undefined} the module owning the export
+					 */
+					const getExportOwnerModule = (exportsInfo, name) => {
+						/** @type {ExportsInfo | undefined} */
+						let current = exportsInfo;
+						while (current !== undefined) {
+							const owner = exportInfoToModuleMap.get(current);
+							if (owner !== undefined) return owner;
+							if (current._exports.has(name)) return;
+							current = current._redirectTo;
+						}
+					};
+
 					/** @type {TupleQueue<[Module], RuntimeSpec>} */
 					const queue = new TupleQueue();
 
@@ -179,7 +198,10 @@ class FlagDependencyUsagePlugin {
 													const currentModule =
 														currentExportsInfo === exportsInfo
 															? module
-															: exportInfoToModuleMap.get(currentExportsInfo);
+															: getExportOwnerModule(
+																	currentExportsInfo,
+																	usedExport[i]
+																);
 													if (currentModule) {
 														queue.enqueue(currentModule, runtime);
 													}
@@ -198,7 +220,10 @@ class FlagDependencyUsagePlugin {
 											const currentModule =
 												currentExportsInfo === exportsInfo
 													? module
-													: exportInfoToModuleMap.get(currentExportsInfo);
+													: getExportOwnerModule(
+															currentExportsInfo,
+															usedExport[i]
+														);
 											if (currentModule) {
 												queue.enqueue(currentModule, runtime);
 											}

package/lib/optimize/InlineExports.js

@@ -170,11 +170,7 @@ const isInlineExportsEnabled = (moduleGraph) =>
  * @returns {boolean} true when inlining is enabled for this module
  */
 const isInlineEnabled = (module) =>
-	Boolean(
-		module.buildInfo &&
-		/** @type {import("../module/Module").BuildInfo} */
-		(module.buildInfo).inlineExports
-	);
+	Boolean(module.buildInfo && module.buildInfo.inlineExports);
 
 /**
  * Check whether an import to `module` for `ids` resolves to an inlined value.
@@ -192,8 +188,9 @@ const isExportInlined = (moduleGraph, module, ids, runtime) => {
 
 /**
  * Whether a used name is an inlined value rather than a property name.
- * @param {unknown} value a used name
- * @returns {value is InlinedUsedName} true when the value is inlined
+ * @template V
+ * @param {V} value a used name
+ * @returns {value is Extract<V, InlinedUsedName>} true when the value is inlined
  */
 const isInlinedUsedName = (value) => value instanceof InlinedUsedName;
 

package/lib/optimize/LazyBarrels.js

@@ -5,7 +5,9 @@
 
 "use strict";
 
+const { ImportPhaseUtils } = require("../dependencies/core/ImportPhase");
 const Dependency = require("../graph/Dependency");
+const isDependencyKind = require("../graph/isDependencyKind");
 
 /** @import Compilation, { DependencyConstructor } from "../Compilation" */
 /** @import ModuleGraph from "../graph/ModuleGraph" */
@@ -76,13 +78,23 @@ const getRequestKey = (dependency) => {
 };
 
 /**
- * Returns true if names were requested and none of them is a local export.
- * Only local exports use the import declarations, so the barrel can defer them until a local export is requested.
+ * Returns whether the re-export reads an `import defer` namespace, which `SideEffectsFlagPlugin` keeps on the barrel.
+ * @param {Dependency} dependency the re-export dependency
+ * @returns {boolean} true, when requesting it runs the barrel
+ */
+const isDeferredReexport = (dependency) =>
+	isDependencyKind(dependency, "esm-import") &&
+	ImportPhaseUtils.isDefer(dependency.phase);
+
+/**
+ * Returns true if names were requested and none of them runs the barrel.
+ * Only a running barrel uses the import declarations, so it can defer them until such a name is requested.
  * @param {Set<string> | true | undefined} forwardedIds names requested before classification
  * @param {Set<string>} localIds locally provided export names
+ * @param {Map<string, string> | undefined} deferredReexports names re-exported from an `import defer` namespace
  * @returns {boolean} true, when import declarations can be deferred
  */
-const canLazyImports = (forwardedIds, localIds) => {
+const canLazyImports = (forwardedIds, localIds, deferredReexports) => {
 	if (
 		forwardedIds === undefined ||
 		forwardedIds === true ||
@@ -92,6 +104,9 @@ const canLazyImports = (forwardedIds, localIds) => {
 	}
 	for (const id of forwardedIds) {
 		if (localIds.has(id)) return false;
+		if (deferredReexports !== undefined && deferredReexports.has(id)) {
+			return false;
+		}
 	}
 	return true;
 };
@@ -319,6 +334,11 @@ class LazyBarrels {
 		this._modules = new WeakMap();
 		/** @type {WeakSet<Dependency>} */
 		this._lazyDependencies = new WeakSet();
+		// without provided exports no import is redirected past the barrel, so it runs
+		/** @type {boolean} */
+		this._canLazyImports = Boolean(
+			compilation.options.optimization.providedExports
+		);
 		lazyBarrelsByModuleGraph.set(compilation.moduleGraph, this);
 	}
 
@@ -429,6 +449,8 @@ class LazyBarrels {
 		/** @type {Set<string>} */
 		const localIds = new Set();
 		let hasFallbackStarReexport = false;
+		/** @type {Map<string, string> | undefined} export name -> request key */
+		let deferredReexports;
 
 		// re-export starts deferred and this compilation's requests activate the ones it needs
 		for (const dep of dependencies) {
@@ -451,7 +473,12 @@ class LazyBarrels {
 			if (info === undefined) info = new LazyBarrelInfo(this._lazyDependencies);
 			info.addLazy(requestKey, dep, factory);
 			if (role === Dependency.LAZY_NAMED_REEXPORT) {
-				info.addForwardId(/** @type {string} */ (dep.lazyName), requestKey);
+				const name = /** @type {string} */ (dep.lazyName);
+				info.addForwardId(name, requestKey);
+				if (isDeferredReexport(dep)) {
+					if (deferredReexports === undefined) deferredReexports = new Map();
+					deferredReexports.set(name, requestKey);
+				}
 			} else if (role === Dependency.LAZY_STAR_REEXPORT) {
 				info.addFallback(requestKey);
 				hasFallbackStarReexport = true;
@@ -461,7 +488,10 @@ class LazyBarrels {
 		// import declarations
 		/** @type {Set<string> | undefined} */
 		let importRequests;
-		if (canLazyImports(forwardedIds, localIds)) {
+		if (
+			this._canLazyImports &&
+			canLazyImports(forwardedIds, localIds, deferredReexports)
+		) {
 			for (const dep of dependencies) {
 				if (dep.lazyRole !== Dependency.LAZY_IMPORT_DECLARATION) continue;
 				const factory = this._getDepFactory(dep);
@@ -478,6 +508,12 @@ class LazyBarrels {
 
 		if (info === undefined) return;
 
+		if (importRequests !== undefined && deferredReexports !== undefined) {
+			for (const [id, requestKey] of deferredReexports) {
+				info.addForwardId(id, new Set([...importRequests, requestKey]));
+			}
+		}
+
 		// local exports: known names, so they skip the star fallback but active the deferred imports
 		if (hasFallbackStarReexport || importRequests !== undefined) {
 			const requests =

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -32,6 +32,8 @@ const { STAGE_DEFAULT } = require("./OptimizationStages");
 /** @import { BuildInfo, BuildMeta } from "../module/Module" */
 /** @import RequestShortener from "../util/RequestShortener" */
 /** @import { RuntimeSpec } from "../util/runtime" */
+/** @import { ResolverWithOptions } from "../resolve/ResolverFactory" */
+/** @import { InputFileSystem } from "../fs/fs" */
 
 /** @typedef {Module | ((requestShortener: RequestShortener) => string)} Problem */
 
@@ -112,11 +114,6 @@ class ModuleConcatenationPlugin {
 	apply(compiler) {
 		const { _backCompat: backCompat } = compiler;
 		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
-			if (compilation.moduleMemCaches) {
-				throw new Error(
-					"optimization.concatenateModules can't be used with cacheUnaffected as module concatenation is a global effect"
-				);
-			}
 			const moduleGraph = compilation.moduleGraph;
 			/** @type {Map<Module, string | ((requestShortener: RequestShortener) => string)>} */
 			const bailoutReasonMap = new Map();
@@ -196,6 +193,7 @@ class ModuleConcatenationPlugin {
 					stage: STAGE_DEFAULT
 				},
 				(allChunks, modules, callback) => {
+					// set once the modules are built, so not yet when the compilation starts
 					const logger = compilation.getLogger(
 						"webpack.ModuleConcatenationPlugin"
 					);
@@ -523,10 +521,10 @@ class ModuleConcatenationPlugin {
 								newModule.build(
 									compilation.options,
 									compilation,
-									/** @type {EXPECTED_ANY} */
-									(null),
-									/** @type {EXPECTED_ANY} */
-									(null),
+									/** @type {ResolverWithOptions} */
+									(/** @type {ResolverWithOptions | null} */ (null)),
+									/** @type {InputFileSystem} */
+									(/** @type {InputFileSystem | null} */ (null)),
 									(err) => {
 										if (err) {
 											if (!err.module) {
@@ -1027,7 +1025,7 @@ class ModuleConcatenationPlugin {
 							)} (expected runtime ${runtimeToString(
 								runtime
 							)}, module is only referenced in ${runtimeToString(
-								/** @type {RuntimeSpec} */ (runtimeCondition)
+								runtimeCondition
 							)})`
 					).join(", ")}`;
 				return cacheFailure(

package/lib/optimize/RealContentHashPlugin.js

@@ -600,9 +600,7 @@ ${referencingAssets
 									);
 								}
 								const digest = hash.digest(
-									/** @type {HashDigest} */ (
-										hashToDigest.get(oldHash) || this._hashDigest
-									)
+									hashToDigest.get(oldHash) || this._hashDigest
 								);
 								hashToNewHash.set(oldHash, digest.slice(0, oldHash.length));
 							}
@@ -650,9 +648,7 @@ ${referencingAssets
 								for (const c of chunks) hash.update(c);
 							}
 							const digest = hash.digest(
-								/** @type {HashDigest} */ (
-									hashToDigest.get(oldHash) || this._hashDigest
-								)
+								hashToDigest.get(oldHash) || this._hashDigest
 							);
 							newHash = digest.slice(0, oldHash.length);
 						}