webpack 5.99.7 → 5.99.8

package/lib/asset/AssetGenerator.js

@@ -33,6 +33,7 @@ const nonNumericOnlyHash = require("../util/nonNumericOnlyHash");
 /** @typedef {import("../../declarations/WebpackOptions").AssetModuleFilename} AssetModuleFilename */
 /** @typedef {import("../../declarations/WebpackOptions").AssetModuleOutputPath} AssetModuleOutputPath */
 /** @typedef {import("../../declarations/WebpackOptions").AssetResourceGeneratorOptions} AssetResourceGeneratorOptions */
+/** @typedef {import("../../declarations/WebpackOptions").HashFunction} HashFunction */
 /** @typedef {import("../../declarations/WebpackOptions").RawPublicPath} RawPublicPath */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Compilation")} Compilation */
@@ -51,7 +52,6 @@ const nonNumericOnlyHash = require("../util/nonNumericOnlyHash");
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("../TemplatedPathPlugin").TemplatePath} TemplatePath */
 /** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/createHash").Algorithm} Algorithm */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 /**
@@ -232,7 +232,7 @@ class AssetGenerator extends Generator {
 	 */
 	static getFullContentHash(module, runtimeTemplate) {
 		const hash = createHash(
-			/** @type {Algorithm} */
+			/** @type {HashFunction} */
 			(runtimeTemplate.outputOptions.hashFunction)
 		);
 

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

@@ -549,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/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 */
 
 /**
@@ -444,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/RequireContextPlugin.js

@@ -80,7 +80,8 @@ class RequireContextPlugin {
 							cachedSetProperty(
 								options.resolveOptions || EMPTY_RESOLVE_OPTIONS,
 								"dependencyType",
-								/** @type {string} */ (options.category)
+								/** @type {string} */
+								(options.category)
 							)
 						).options;
 

package/lib/dependencies/WorkerPlugin.js

@@ -34,6 +34,7 @@ const WorkerDependency = require("./WorkerDependency");
 /** @typedef {import("estree").Property} Property */
 /** @typedef {import("estree").SpreadElement} SpreadElement */
 /** @typedef {import("../../declarations/WebpackOptions").ChunkLoading} ChunkLoading */
+/** @typedef {import("../../declarations/WebpackOptions").HashFunction} HashFunction */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../../declarations/WebpackOptions").OutputModule} OutputModule */
 /** @typedef {import("../../declarations/WebpackOptions").WasmLoading} WasmLoading */
@@ -47,7 +48,6 @@ const WorkerDependency = require("./WorkerDependency");
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../javascript/JavascriptParser")} Parser */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../util/createHash").Algorithm} Algorithm */
 /** @typedef {import("./HarmonyImportDependencyParserPlugin").HarmonySettings} HarmonySettings */
 
 /**
@@ -376,7 +376,7 @@ class WorkerPlugin {
 								parser.state.module.identifier()
 							)}|${i}`;
 							const hash = createHash(
-								/** @type {Algorithm} */
+								/** @type {HashFunction} */
 								(compilation.outputOptions.hashFunction)
 							);
 							hash.update(name);

package/lib/hmr/JavascriptHotModuleReplacement.runtime.js

@@ -117,7 +117,6 @@ module.exports = function () {
 		for (var moduleId in currentUpdate) {
 			if ($hasOwnProperty$(currentUpdate, moduleId)) {
 				var newModuleFactory = currentUpdate[moduleId];
-				/** @type {TODO} */
 				var result = newModuleFactory
 					? getAffectedModuleEffects(moduleId)
 					: {

package/lib/index.js

@@ -11,20 +11,30 @@ const memoize = require("./util/memoize");
 /** @typedef {import("../declarations/WebpackOptions").Entry} Entry */
 /** @typedef {import("../declarations/WebpackOptions").EntryNormalized} EntryNormalized */
 /** @typedef {import("../declarations/WebpackOptions").EntryObject} EntryObject */
+/** @typedef {import("../declarations/WebpackOptions").ExternalItem} ExternalItem */
+/** @typedef {import("../declarations/WebpackOptions").ExternalItemFunction} ExternalItemFunction */
+/** @typedef {import("../declarations/WebpackOptions").ExternalItemFunctionCallback} ExternalItemFunctionCallback */
 /** @typedef {import("../declarations/WebpackOptions").ExternalItemFunctionData} ExternalItemFunctionData */
+/** @typedef {import("../declarations/WebpackOptions").ExternalItemFunctionDataGetResolve} ExternalItemFunctionDataGetResolve */
+/** @typedef {import("../declarations/WebpackOptions").ExternalItemFunctionDataGetResolveCallbackResult} ExternalItemFunctionDataGetResolveCallbackResult */
+/** @typedef {import("../declarations/WebpackOptions").ExternalItemFunctionDataGetResolveResult} ExternalItemFunctionDataGetResolveResult */
+/** @typedef {import("../declarations/WebpackOptions").ExternalItemFunctionPromise} ExternalItemFunctionPromise */
 /** @typedef {import("../declarations/WebpackOptions").ExternalItemObjectKnown} ExternalItemObjectKnown */
 /** @typedef {import("../declarations/WebpackOptions").ExternalItemObjectUnknown} ExternalItemObjectUnknown */
 /** @typedef {import("../declarations/WebpackOptions").ExternalItemValue} ExternalItemValue */
 /** @typedef {import("../declarations/WebpackOptions").Externals} Externals */
 /** @typedef {import("../declarations/WebpackOptions").FileCacheOptions} FileCacheOptions */
+/** @typedef {import("../declarations/WebpackOptions").GeneratorOptionsByModuleTypeKnown} GeneratorOptionsByModuleTypeKnown */
 /** @typedef {import("../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
 /** @typedef {import("../declarations/WebpackOptions").MemoryCacheOptions} MemoryCacheOptions */
 /** @typedef {import("../declarations/WebpackOptions").ModuleOptions} ModuleOptions */
+/** @typedef {import("../declarations/WebpackOptions").ParserOptionsByModuleTypeKnown} ParserOptionsByModuleTypeKnown */
 /** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
 /** @typedef {import("../declarations/WebpackOptions").RuleSetCondition} RuleSetCondition */
 /** @typedef {import("../declarations/WebpackOptions").RuleSetConditionAbsolute} RuleSetConditionAbsolute */
 /** @typedef {import("../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
 /** @typedef {import("../declarations/WebpackOptions").RuleSetUse} RuleSetUse */
+/** @typedef {import("../declarations/WebpackOptions").RuleSetUseFunction} RuleSetUseFunction */
 /** @typedef {import("../declarations/WebpackOptions").RuleSetUseItem} RuleSetUseItem */
 /** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptions} Configuration */
@@ -37,6 +47,7 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./Compilation").EntryOptions} EntryOptions */
 /** @typedef {import("./Compilation").PathData} PathData */
 /** @typedef {import("./Compiler").AssetEmittedInfo} AssetEmittedInfo */
+/** @typedef {import("./Entrypoint")} Entrypoint */
 /** @typedef {import("./MultiCompiler").MultiCompilerOptions} MultiCompilerOptions */
 /** @typedef {import("./MultiStats")} MultiStats */
 /** @typedef {import("./NormalModuleFactory").ResolveData} ResolveData */

package/lib/javascript/JavascriptModulesPlugin.js

@@ -52,6 +52,7 @@ const JavascriptParser = require("./JavascriptParser");
 /** @typedef {import("eslint-scope").Variable} Variable */
 /** @typedef {import("estree").Program} Program */
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").HashFunction} HashFunction */
 /** @typedef {import("../../declarations/WebpackOptions").Output} OutputOptions */
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
@@ -69,7 +70,6 @@ const JavascriptParser = require("./JavascriptParser");
 /** @typedef {import("../WebpackError")} WebpackError */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/createHash").Algorithm} Algorithm */
 
 /**
  * @param {Chunk} chunk a chunk
@@ -429,7 +429,7 @@ class JavascriptModulesPlugin {
 							hashFunction
 						}
 					} = compilation;
-					const hash = createHash(/** @type {Algorithm} */ (hashFunction));
+					const hash = createHash(/** @type {HashFunction} */ (hashFunction));
 					if (hashSalt) hash.update(hashSalt);
 					if (chunk.hasRuntime()) {
 						this.updateHashWithBootstrap(

package/lib/json/JsonModulesPlugin.js

@@ -16,8 +16,8 @@ const JsonParser = require("./JsonParser");
 /** @typedef {import("../util/fs").JsonValue} JsonValue */
 
 const validate = createSchemaValidation(
-	require("../../schemas/plugins/JsonModulesPluginParser.check.js"),
-	() => require("../../schemas/plugins/JsonModulesPluginParser.json"),
+	require("../../schemas/plugins/json/JsonModulesPluginParser.check.js"),
+	() => require("../../schemas/plugins/json/JsonModulesPluginParser.json"),
 	{
 		name: "Json Modules Plugin",
 		baseDataPath: "parser"
@@ -25,8 +25,8 @@ const validate = createSchemaValidation(
 );
 
 const validateGenerator = createSchemaValidation(
-	require("../../schemas/plugins/JsonModulesPluginGenerator.check.js"),
-	() => require("../../schemas/plugins/JsonModulesPluginGenerator.json"),
+	require("../../schemas/plugins/json/JsonModulesPluginGenerator.check.js"),
+	() => require("../../schemas/plugins/json/JsonModulesPluginGenerator.json"),
 	{
 		name: "Json Modules Plugin",
 		baseDataPath: "generator"

package/lib/library/AbstractLibraryPlugin.js

@@ -93,7 +93,7 @@ class AbstractLibraryPlugin {
 
 			/**
 			 * @param {Chunk} chunk chunk
-			 * @returns {TODO} options for the chunk
+			 * @returns {T | false} options for the chunk
 			 */
 			const getOptionsForChunk = chunk => {
 				if (compilation.chunkGraph.getNumberOfEntryModules(chunk) === 0)

package/lib/node/nodeConsole.js

@@ -8,6 +8,7 @@
 const util = require("util");
 const truncateArgs = require("../logging/truncateArgs");
 
+/** @typedef {import("../../declarations/WebpackOptions").InfrastructureLogging} InfrastructureLogging */
 /** @typedef {import("../logging/createConsoleLogger").LoggerConsole} LoggerConsole */
 
 /* eslint-disable no-console */
@@ -16,7 +17,7 @@ const truncateArgs = require("../logging/truncateArgs");
  * @param {object} options options
  * @param {boolean=} options.colors colors
  * @param {boolean=} options.appendOnly append only
- * @param {NodeJS.WritableStream} options.stream stream
+ * @param {NonNullable<InfrastructureLogging["stream"]>} options.stream stream
  * @returns {LoggerConsole} logger function
  */
 module.exports = ({ colors, appendOnly, stream }) => {
@@ -57,7 +58,7 @@ module.exports = ({ colors, appendOnly, stream }) => {
 
 	const writeStatusMessage = () => {
 		if (!currentStatusMessage) return;
-		const l = /** @type {TODO} */ (stream).columns || 40;
+		const l = stream.columns || 40;
 		const args = truncateArgs(currentStatusMessage, l - 1);
 		const str = args.join(" ");
 		const coloredStr = `\u001B[1m${str}\u001B[39m\u001B[22m`;

package/lib/optimize/AggressiveSplittingPlugin.js

@@ -195,7 +195,7 @@ class AggressiveSplittingPlugin {
 								moveModuleBetween(chunkGraph, chunk, newChunk)(module);
 							}
 							chunk.split(newChunk);
-							chunk.name = /** @type {TODO} */ (null);
+							chunk.name = null;
 						}
 						fromAggressiveSplittingSet.add(newChunk);
 						chunkSplitDataMap.set(newChunk, splitData);

package/lib/optimize/ConcatenatedModule.js

@@ -1739,7 +1739,9 @@ ${defineGetters}`
 						sourceType: "module"
 					});
 				} catch (_err) {
-					const err = /** @type {TODO} */ (_err);
+					const err =
+						/** @type {Error & { loc?: { line: number, column: number } }} */
+						(_err);
 					if (
 						err.loc &&
 						typeof err.loc === "object" &&

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -398,9 +398,9 @@ class ModuleConcatenationPlugin {
 								newModule.build(
 									compiler.options,
 									compilation,
-									/** @type {TODO} */
+									/** @type {EXPECTED_ANY} */
 									(null),
-									/** @type {TODO} */
+									/** @type {EXPECTED_ANY} */
 									(null),
 									err => {
 										if (err) {

package/lib/optimize/RuntimeChunkPlugin.js

@@ -11,16 +11,15 @@
 
 const PLUGIN_NAME = "RuntimeChunkPlugin";
 
+/** @typedef {(entrypoint: { name: string }) => string} RuntimeChunkFunction */
+
 class RuntimeChunkPlugin {
 	/**
-	 * @param {{ name?: (entrypoint: { name: string }) => string }} options options
+	 * @param {{ name?: RuntimeChunkFunction }=} options options
 	 */
 	constructor(options) {
 		this.options = {
-			/**
-			 * @param {Entrypoint} entrypoint entrypoint name
-			 * @returns {string} runtime chunk name
-			 */
+			/** @type {RuntimeChunkFunction} */
 			name: entrypoint => `runtime~${entrypoint.name}`,
 			...options
 		};
@@ -41,7 +40,7 @@ class RuntimeChunkPlugin {
 				if (data.options.runtime === undefined && !data.options.dependOn) {
 					// Determine runtime chunk name
 					let name =
-						/** @type {string | ((entrypoint: { name: string }) => string)} */
+						/** @type {string | RuntimeChunkFunction} */
 						(this.options.name);
 					if (typeof name === "function") {
 						name = name({ name: entryName });

package/lib/optimize/SideEffectsFlagPlugin.js

@@ -145,7 +145,8 @@ class SideEffectsFlagPlugin {
 										if (
 											!parser.isPure(
 												statement.expression,
-												/** @type {Range} */ (statement.range)[0]
+												/** @type {Range} */
+												(statement.range)[0]
 											)
 										) {
 											sideEffectsStatement = statement;
@@ -157,7 +158,8 @@ class SideEffectsFlagPlugin {
 										if (
 											!parser.isPure(
 												statement.test,
-												/** @type {Range} */ (statement.range)[0]
+												/** @type {Range} */
+												(statement.range)[0]
 											)
 										) {
 											sideEffectsStatement = statement;
@@ -193,7 +195,8 @@ class SideEffectsFlagPlugin {
 										if (
 											!parser.isPure(
 												statement.discriminant,
-												/** @type {Range} */ (statement.range)[0]
+												/** @type {Range} */
+												(statement.range)[0]
 											)
 										) {
 											sideEffectsStatement = statement;
@@ -216,9 +219,9 @@ class SideEffectsFlagPlugin {
 									case "ExportDefaultDeclaration":
 										if (
 											!parser.isPure(
-												/** @type {TODO} */
-												(statement.declaration),
-												/** @type {Range} */ (statement.range)[0]
+												statement.declaration,
+												/** @type {Range} */
+												(statement.range)[0]
 											)
 										) {
 											sideEffectsStatement = statement;

package/lib/optimize/SplitChunksPlugin.js

@@ -21,6 +21,7 @@ const { makePathsRelative } = require("../util/identifier");
 const memoize = require("../util/memoize");
 const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 
+/** @typedef {import("../../declarations/WebpackOptions").HashFunction} HashFunction */
 /** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksCacheGroup} OptimizationSplitChunksCacheGroup */
 /** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksGetCacheGroups} OptimizationSplitChunksGetCacheGroups */
 /** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksOptions} OptimizationSplitChunksOptions */
@@ -33,7 +34,6 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../TemplatedPathPlugin").TemplatePath} TemplatePath */
-/** @typedef {import("../util/createHash").Algorithm} Algorithm */
 /** @typedef {import("../util/deterministicGrouping").GroupedItems<Module>} DeterministicGroupingGroupedItemsForModule */
 /** @typedef {import("../util/deterministicGrouping").Options<Module>} DeterministicGroupingOptionsForModule */
 
@@ -184,7 +184,7 @@ const hashFilename = (name, outputOptions) => {
 	const digest =
 		/** @type {string} */
 		(
-			createHash(/** @type {Algorithm} */ (outputOptions.hashFunction))
+			createHash(/** @type {HashFunction} */ (outputOptions.hashFunction))
 				.update(name)
 				.digest(outputOptions.hashDigest)
 		);

package/lib/rules/BasicEffectRulePlugin.js

@@ -37,8 +37,7 @@ class BasicEffectRulePlugin {
 				if (unhandledProperties.has(this.ruleProperty)) {
 					unhandledProperties.delete(this.ruleProperty);
 
-					const value =
-						rule[/** @type {keyof RuleSetRule} */ (this.ruleProperty)];
+					const value = rule[this.ruleProperty];
 
 					result.effects.push({
 						type: this.effectType,

package/lib/rules/ObjectMatcherRulePlugin.js

@@ -8,6 +8,7 @@
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetConditionOrConditions} RuleSetConditionOrConditions */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
 /** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
+/** @typedef {import("./RuleSetCompiler").EffectData} EffectData */
 /** @typedef {import("./RuleSetCompiler").RuleCondition} RuleCondition */
 /** @typedef {import("./RuleSetCompiler").RuleConditionFunction} RuleConditionFunction */
 
@@ -22,7 +23,7 @@
 class ObjectMatcherRulePlugin {
 	/**
 	 * @param {ObjectMatcherRuleKeys} ruleProperty the rule property
-	 * @param {string=} dataProperty the data property
+	 * @param {keyof EffectData=} dataProperty the data property
 	 * @param {RuleConditionFunction=} additionalConditionFunction need to check
 	 */
 	constructor(ruleProperty, dataProperty, additionalConditionFunction) {

package/lib/rules/RuleSetCompiler.js

@@ -13,7 +13,9 @@ const { SyncHook } = require("tapable");
 
 /** @typedef {(Falsy | RuleSetRule)[]} RuleSetRules */
 
-/** @typedef {(value: string | EffectData) => boolean} RuleConditionFunction */
+/**
+ * @typedef {(value: EffectData[keyof EffectData]) => boolean} RuleConditionFunction
+ */
 
 /**
  * @typedef {object} RuleCondition
@@ -29,7 +31,19 @@ const { SyncHook } = require("tapable");
  */
 
 /**
- * @typedef {Record<string, TODO>} EffectData
+ * @typedef {object} EffectData
+ * @property {string=} resource
+ * @property {string=} realResource
+ * @property {string=} resourceQuery
+ * @property {string=} resourceFragment
+ * @property {string=} scheme
+ * @property {ImportAttributes=} assertions
+ * @property {string=} mimetype
+ * @property {string} dependency
+ * @property {Record<string, EXPECTED_ANY>} descriptionData
+ * @property {string=} compiler
+ * @property {string} issuer
+ * @property {string} issuerLayer
  */
 
 /**
@@ -102,7 +116,7 @@ class RuleSetCompiler {
 			for (const condition of rule.conditions) {
 				const p = condition.property;
 				if (Array.isArray(p)) {
-					/** @type {EffectData | string | undefined} */
+					/** @type {EffectData | EffectData[keyof EffectData] | undefined} */
 					let current = data;
 					for (const subProperty of p) {
 						if (
@@ -110,7 +124,7 @@ class RuleSetCompiler {
 							typeof current === "object" &&
 							Object.prototype.hasOwnProperty.call(current, subProperty)
 						) {
-							current = current[subProperty];
+							current = current[/** @type {keyof EffectData} */ (subProperty)];
 						} else {
 							current = undefined;
 							break;
@@ -121,7 +135,7 @@ class RuleSetCompiler {
 						continue;
 					}
 				} else if (p in data) {
-					const value = data[p];
+					const value = data[/** @type {keyof EffectData} */ (p)];
 					if (value !== undefined) {
 						if (!condition.fn(value)) return false;
 						continue;