webpack 5.98.0 → 5.99.0

package/lib/optimize/SideEffectsFlagPlugin.js

@@ -16,6 +16,8 @@ const HarmonyExportImportedSpecifierDependency = require("../dependencies/Harmon
 const HarmonyImportSpecifierDependency = require("../dependencies/HarmonyImportSpecifierDependency");
 const formatLocation = require("../formatLocation");
 
+/** @typedef {import("estree").MaybeNamedClassDeclaration} MaybeNamedClassDeclaration */
+/** @typedef {import("estree").MaybeNamedFunctionDeclaration} MaybeNamedFunctionDeclaration */
 /** @typedef {import("estree").ModuleDeclaration} ModuleDeclaration */
 /** @typedef {import("estree").Statement} Statement */
 /** @typedef {import("../Compiler")} Compiler */
@@ -43,7 +45,7 @@ const formatLocation = require("../formatLocation");
 
 /** @typedef {Map<string, RegExp>} CacheItem */
 
-/** @type {WeakMap<any, CacheItem>} */
+/** @type {WeakMap<Compiler, CacheItem>} */
 const globToRegexpCache = new WeakMap();
 
 /**
@@ -128,7 +130,7 @@ class SideEffectsFlagPlugin {
 					 * @returns {void}
 					 */
 					const parserHandler = parser => {
-						/** @type {undefined | Statement | ModuleDeclaration} */
+						/** @type {undefined | Statement | ModuleDeclaration | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration} */
 						let sideEffectsStatement;
 						parser.hooks.program.tap(PLUGIN_NAME, () => {
 							sideEffectsStatement = undefined;

package/lib/optimize/SplitChunksPlugin.js

@@ -32,6 +32,7 @@ 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 */
 
@@ -52,7 +53,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 
 /**
  * @typedef {object} CacheGroupSource
- * @property {string=} key
+ * @property {string} key
  * @property {number=} priority
  * @property {GetName=} getName
  * @property {ChunkFilterFunction=} chunksFilter
@@ -76,20 +77,20 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 /**
  * @typedef {object} CacheGroup
  * @property {string} key
- * @property {number=} priority
+ * @property {number} priority
  * @property {GetName=} getName
- * @property {ChunkFilterFunction=} chunksFilter
+ * @property {ChunkFilterFunction} chunksFilter
  * @property {SplitChunksSizes} minSize
  * @property {SplitChunksSizes} minSizeReduction
  * @property {SplitChunksSizes} minRemainingSize
  * @property {SplitChunksSizes} enforceSizeThreshold
  * @property {SplitChunksSizes} maxAsyncSize
  * @property {SplitChunksSizes} maxInitialSize
- * @property {number=} minChunks
- * @property {number=} maxAsyncRequests
- * @property {number=} maxInitialRequests
+ * @property {number} minChunks
+ * @property {number} maxAsyncRequests
+ * @property {number} maxInitialRequests
  * @property {TemplatePath=} filename
- * @property {string=} idHint
+ * @property {string} idHint
  * @property {string} automaticNameDelimiter
  * @property {boolean} reuseExistingChunk
  * @property {boolean} usedExports
@@ -118,14 +119,14 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @callback GetCacheGroups
  * @param {Module} module
  * @param {CacheGroupsContext} context
- * @returns {CacheGroupSource[]}
+ * @returns {CacheGroupSource[] | null}
  */
 
 /**
  * @callback GetName
- * @param {Module=} module
- * @param {Chunk[]=} chunks
- * @param {string=} key
+ * @param {Module} module
+ * @param {Chunk[]} chunks
+ * @param {string} key
  * @returns {string=}
  */
 
@@ -143,7 +144,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {number} maxAsyncRequests
  * @property {number} maxInitialRequests
  * @property {boolean} hidePathInfo
- * @property {TemplatePath} filename
+ * @property {TemplatePath=} filename
  * @property {string} automaticNameDelimiter
  * @property {GetCacheGroups} getCacheGroups
  * @property {GetName} getName
@@ -156,17 +157,18 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {SortableSet<Module>} modules
  * @property {CacheGroup} cacheGroup
  * @property {number} cacheGroupIndex
- * @property {string} name
+ * @property {string=} name
  * @property {Record<string, number>} sizes
  * @property {Set<Chunk>} chunks
  * @property {Set<Chunk>} reusableChunks
  * @property {Set<bigint | Chunk>} chunksKeys
  */
 
-const defaultGetName = /** @type {GetName} */ (() => {});
+/** @type {GetName} */
+const defaultGetName = () => undefined;
 
 const deterministicGroupingForModules =
-	/** @type {function(DeterministicGroupingOptionsForModule): DeterministicGroupingGroupedItemsForModule[]} */
+	/** @type {(options: DeterministicGroupingOptionsForModule) => DeterministicGroupingGroupedItemsForModule[]} */
 	(deterministicGrouping);
 
 /** @type {WeakMap<Module, string>} */
@@ -181,7 +183,7 @@ const hashFilename = (name, outputOptions) => {
 	const digest =
 		/** @type {string} */
 		(
-			createHash(outputOptions.hashFunction)
+			createHash(/** @type {Algorithm} */ (outputOptions.hashFunction))
 				.update(name)
 				.digest(outputOptions.hashDigest)
 		);
@@ -404,7 +406,7 @@ const totalSize = sizes => {
 };
 
 /**
- * @param {false|string|Function|undefined} name the chunk name
+ * @param {OptimizationSplitChunksCacheGroup["name"]} name the chunk name
  * @returns {GetName | undefined} a function to get the name of the chunk
  */
 const normalizeName = name => {
@@ -418,7 +420,7 @@ const normalizeName = name => {
 
 /**
  * @param {OptimizationSplitChunksCacheGroup["chunks"]} chunks the chunk filter option
- * @returns {ChunkFilterFunction} the chunk filter function
+ * @returns {ChunkFilterFunction | undefined} the chunk filter function
  */
 const normalizeChunksFilter = chunks => {
 	if (chunks === "initial") {
@@ -439,7 +441,7 @@ const normalizeChunksFilter = chunks => {
 };
 
 /**
- * @param {GetCacheGroups | Record<string, false|string|RegExp|OptimizationSplitChunksGetCacheGroups|OptimizationSplitChunksCacheGroup>} cacheGroups the cache group options
+ * @param {undefined | GetCacheGroups | Record<string, false | string | RegExp | OptimizationSplitChunksGetCacheGroups | OptimizationSplitChunksCacheGroup>} cacheGroups the cache group options
  * @param {string[]} defaultSizeTypes the default size types
  * @returns {GetCacheGroups} a function to get the cache groups
  */
@@ -448,7 +450,7 @@ const normalizeCacheGroups = (cacheGroups, defaultSizeTypes) => {
 		return cacheGroups;
 	}
 	if (typeof cacheGroups === "object" && cacheGroups !== null) {
-		/** @type {(function(Module, CacheGroupsContext, CacheGroupSource[]): void)[]} */
+		/** @type {((module: Module, context: CacheGroupsContext, results: CacheGroupSource[]) => void)[]} */
 		const handlers = [];
 		for (const key of Object.keys(cacheGroups)) {
 			const option = cacheGroups[key];
@@ -516,7 +518,7 @@ const normalizeCacheGroups = (cacheGroups, defaultSizeTypes) => {
 };
 
 /**
- * @param {undefined|boolean|string|RegExp|Function} test test option
+ * @param {OptimizationSplitChunksCacheGroup["test"]} test test option
  * @param {Module} module the module
  * @param {CacheGroupsContext} context context object
  * @returns {boolean} true, if the module should be selected
@@ -529,17 +531,17 @@ const checkTest = (test, module, context) => {
 	if (typeof test === "boolean") return test;
 	if (typeof test === "string") {
 		const name = module.nameForCondition();
-		return name && name.startsWith(test);
+		return name ? name.startsWith(test) : false;
 	}
 	if (test instanceof RegExp) {
 		const name = module.nameForCondition();
-		return name && test.test(name);
+		return name ? test.test(name) : false;
 	}
 	return false;
 };
 
 /**
- * @param {undefined|string|RegExp|Function} test type option
+ * @param {OptimizationSplitChunksCacheGroup["type"]} test type option
  * @param {Module} module the module
  * @returns {boolean} true, if the module should be selected
  */
@@ -560,7 +562,7 @@ const checkModuleType = (test, module) => {
 };
 
 /**
- * @param {undefined|string|RegExp|Function} test type option
+ * @param {OptimizationSplitChunksCacheGroup["layer"]} test type option
  * @param {Module} module the module
  * @returns {boolean} true, if the module should be selected
  */
@@ -571,11 +573,11 @@ const checkModuleLayer = (test, module) => {
 	}
 	if (typeof test === "string") {
 		const layer = module.layer;
-		return test === "" ? !layer : layer && layer.startsWith(test);
+		return test === "" ? !layer : layer ? layer.startsWith(test) : false;
 	}
 	if (test instanceof RegExp) {
 		const layer = module.layer;
-		return test.test(layer);
+		return layer ? test.test(layer) : false;
 	}
 	return false;
 };
@@ -647,7 +649,9 @@ module.exports = class SplitChunksPlugin {
 
 		/** @type {SplitChunksOptions} */
 		this.options = {
-			chunksFilter: normalizeChunksFilter(options.chunks || "all"),
+			chunksFilter:
+				/** @type {ChunkFilterFunction} */
+				(normalizeChunksFilter(options.chunks || "all")),
 			defaultSizeTypes,
 			minSize,
 			minSizeReduction,
@@ -676,13 +680,19 @@ module.exports = class SplitChunksPlugin {
 				options.cacheGroups,
 				defaultSizeTypes
 			),
-			getName: options.name ? normalizeName(options.name) : defaultGetName,
-			automaticNameDelimiter: options.automaticNameDelimiter,
-			usedExports: options.usedExports,
+			getName: options.name
+				? /** @type {GetName} */ (normalizeName(options.name))
+				: defaultGetName,
+			automaticNameDelimiter: options.automaticNameDelimiter || "-",
+			usedExports: options.usedExports || false,
 			fallbackCacheGroup: {
-				chunksFilter: normalizeChunksFilter(
-					fallbackCacheGroup.chunks || options.chunks || "all"
-				),
+				chunksFilter:
+					/** @type {ChunkFilterFunction} */
+					(
+						normalizeChunksFilter(
+							fallbackCacheGroup.chunks || options.chunks || "all"
+						)
+					),
 				minSize: mergeSizes(
 					normalizeSizes(fallbackCacheGroup.minSize, defaultSizeTypes),
 					minSize
@@ -733,6 +743,7 @@ module.exports = class SplitChunksPlugin {
 			cacheGroupSource.enforceSizeThreshold,
 			cacheGroupSource.enforce ? undefined : this.options.enforceSizeThreshold
 		);
+		/** @type {CacheGroup} */
 		const cacheGroup = {
 			key: cacheGroupSource.key,
 			priority: cacheGroupSource.priority || 0,
@@ -853,10 +864,11 @@ module.exports = class SplitChunksPlugin {
 						result = iterator.next();
 						if (result.done) return first;
 						let key =
-							chunkIndexMap.get(first) | chunkIndexMap.get(result.value);
+							/** @type {bigint} */ (chunkIndexMap.get(first)) |
+							/** @type {bigint} */ (chunkIndexMap.get(result.value));
 						while (!(result = iterator.next()).done) {
 							const raw = chunkIndexMap.get(result.value);
-							key = key ^ raw;
+							key = key ^ /** @type {bigint} */ (raw);
 						}
 						return key;
 					};
@@ -866,7 +878,7 @@ module.exports = class SplitChunksPlugin {
 					 */
 					const keyToString = key => {
 						if (typeof key === "bigint") return key.toString(16);
-						return chunkIndexMap.get(key).toString(16);
+						return /** @type {bigint} */ (chunkIndexMap.get(key)).toString(16);
 					};
 
 					const getChunkSetsInGraph = memoize(() => {
@@ -911,7 +923,7 @@ module.exports = class SplitChunksPlugin {
 					const groupedByExportsMap = new Map();
 
 					const getExportsChunkSetsInGraph = memoize(() => {
-						/** @type {Map<bigint, Set<Chunk>>} */
+						/** @type {Map<bigint | Chunk, Set<Chunk>>} */
 						const chunkSetsInGraph = new Map();
 						/** @type {Set<Chunk>} */
 						const singleChunkSets = new Set();
@@ -922,7 +934,7 @@ module.exports = class SplitChunksPlugin {
 								if (chunks.length === 1) {
 									singleChunkSets.add(chunks[0]);
 								} else {
-									const chunksKey = /** @type {bigint} */ (getKey(chunks));
+									const chunksKey = getKey(chunks);
 									if (!chunkSetsInGraph.has(chunksKey)) {
 										chunkSetsInGraph.set(chunksKey, new Set(chunks));
 									}
@@ -965,6 +977,12 @@ module.exports = class SplitChunksPlugin {
 					);
 
 					// Create a list of possible combinations
+					/**
+					 * @param {Map<bigint | Chunk, Set<Chunk>>} chunkSets chunk sets
+					 * @param {Set<Chunk>} singleChunkSets single chunks sets
+					 * @param {Map<number, Set<Chunk>[]>} chunkSetsByCount chunk sets by count
+					 * @returns {(key: bigint | Chunk) => (Set<Chunk> | Chunk)[]} combinations
+					 */
 					const createGetCombinations = (
 						chunkSets,
 						singleChunkSets,
@@ -981,7 +999,9 @@ module.exports = class SplitChunksPlugin {
 								combinationsCache.set(key, result);
 								return result;
 							}
-							const chunksSet = chunkSets.get(key);
+							const chunksSet =
+								/** @type {Set<Chunk>} */
+								(chunkSets.get(key));
 							/** @type {(Set<Chunk> | Chunk)[]} */
 							const array = [chunksSet];
 							for (const [count, setArray] of chunkSetsByCount) {
@@ -1012,6 +1032,11 @@ module.exports = class SplitChunksPlugin {
 							getChunkSetsByCount()
 						);
 					});
+
+					/**
+					 * @param {bigint | Chunk} key key
+					 * @returns {(Set<Chunk> | Chunk)[]} combinations by key
+					 */
 					const getCombinations = key => getCombinationsFactory()(key);
 
 					const getExportsCombinationsFactory = memoize(() => {
@@ -1023,6 +1048,10 @@ module.exports = class SplitChunksPlugin {
 							getExportsChunkSetsByCount()
 						);
 					});
+					/**
+					 * @param {bigint | Chunk} key key
+					 * @returns {(Set<Chunk> | Chunk)[]} exports combinations by key
+					 */
 					const getExportsCombinations = key =>
 						getExportsCombinationsFactory()(key);
 
@@ -1098,11 +1127,12 @@ module.exports = class SplitChunksPlugin {
 						// Break if minimum number of chunks is not reached
 						if (selectedChunks.length < cacheGroup.minChunks) return;
 						// Determine name for split chunk
+
 						const name =
-							/** @type {string} */
-							(cacheGroup.getName(module, selectedChunks, cacheGroup.key));
+							/** @type {GetName} */
+							(cacheGroup.getName)(module, selectedChunks, cacheGroup.key);
 						// Check if the name is ok
-						const existingChunk = compilation.namedChunks.get(name);
+						const existingChunk = name && compilation.namedChunks.get(name);
 						if (existingChunk) {
 							const parentValidationKey = `${name}|${
 								typeof selectedChunksKey === "bigint"
@@ -1167,7 +1197,7 @@ module.exports = class SplitChunksPlugin {
 								? ` name:${name}`
 								: ` chunks:${keyToString(selectedChunksKey)}`);
 						// Add module to maps
-						let info = /** @type {ChunksInfoItem} */ (chunksInfoMap.get(key));
+						let info = chunksInfoMap.get(key);
 						if (info === undefined) {
 							chunksInfoMap.set(
 								key,
@@ -1260,7 +1290,8 @@ module.exports = class SplitChunksPlugin {
 								const { chunks: selectedChunks, key: selectedChunksKey } =
 									getSelectedChunks(
 										chunkCombination,
-										/** @type {ChunkFilterFunction} */ (cacheGroup.chunksFilter)
+										/** @type {ChunkFilterFunction} */
+										(cacheGroup.chunksFilter)
 									);
 
 								addModuleToChunksInfoMap(
@@ -1428,18 +1459,14 @@ module.exports = class SplitChunksPlugin {
 						) {
 							for (const chunk of usedChunks) {
 								// respect max requests
-								const maxRequests = /** @type {number} */ (
-									chunk.isOnlyInitial()
-										? item.cacheGroup.maxInitialRequests
-										: chunk.canBeInitial()
-											? Math.min(
-													/** @type {number} */
-													(item.cacheGroup.maxInitialRequests),
-													/** @type {number} */
-													(item.cacheGroup.maxAsyncRequests)
-												)
-											: item.cacheGroup.maxAsyncRequests
-								);
+								const maxRequests = chunk.isOnlyInitial()
+									? item.cacheGroup.maxInitialRequests
+									: chunk.canBeInitial()
+										? Math.min(
+												item.cacheGroup.maxInitialRequests,
+												item.cacheGroup.maxAsyncRequests
+											)
+										: item.cacheGroup.maxAsyncRequests;
 								if (
 									Number.isFinite(maxRequests) &&
 									getRequests(chunk) >= maxRequests
@@ -1461,10 +1488,7 @@ module.exports = class SplitChunksPlugin {
 						if (usedChunks.size < item.chunks.size) {
 							if (isExistingChunk)
 								usedChunks.add(/** @type {Chunk} */ (newChunk));
-							if (
-								/** @type {number} */ (usedChunks.size) >=
-								/** @type {number} */ (item.cacheGroup.minChunks)
-							) {
+							if (usedChunks.size >= item.cacheGroup.minChunks) {
 								const chunksArr = Array.from(usedChunks);
 								for (const module of item.modules) {
 									addModuleToChunksInfoMap(
@@ -1738,9 +1762,7 @@ module.exports = class SplitChunksPlugin {
 									hashFilename(name, outputOptions);
 							}
 							if (i !== results.length - 1) {
-								const newPart = compilation.addChunk(
-									/** @type {Chunk["name"]} */ (name)
-								);
+								const newPart = compilation.addChunk(name);
 								chunk.split(newPart);
 								newPart.chunkReason = chunk.chunkReason;
 								if (chunk.filenameTemplate) {
@@ -1758,7 +1780,7 @@ module.exports = class SplitChunksPlugin {
 								}
 							} else {
 								// change the chunk to be a part
-								chunk.name = /** @type {Chunk["name"]} */ (name);
+								chunk.name = name;
 							}
 						}
 					}

package/lib/rules/BasicEffectRulePlugin.js

@@ -8,9 +8,17 @@
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
 /** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
 
+/**
+ * @template T
+ * @template {T[keyof T]} V
+ * @typedef {import("./RuleSetCompiler").KeysOfTypes<T, V>} KeysOfTypes
+ */
+
+/** @typedef {KeysOfTypes<RuleSetRule, string | boolean | { [k: string]: EXPECTED_ANY }>} BasicEffectRuleKeys */
+
 class BasicEffectRulePlugin {
 	/**
-	 * @param {string} ruleProperty the rule property
+	 * @param {BasicEffectRuleKeys} ruleProperty the rule property
 	 * @param {string=} effectType the effect type
 	 */
 	constructor(ruleProperty, effectType) {

package/lib/rules/BasicMatcherRulePlugin.js

@@ -5,13 +5,24 @@
 
 "use strict";
 
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetConditionOrConditions} RuleSetConditionOrConditions */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetConditionOrConditionsAbsolute} RuleSetConditionOrConditionsAbsolute */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetLoaderOptions} RuleSetLoaderOptions */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
 /** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
 /** @typedef {import("./RuleSetCompiler").RuleCondition} RuleCondition */
 
+/**
+ * @template T
+ * @template {T[keyof T]} V
+ * @typedef {import("./RuleSetCompiler").KeysOfTypes<T, V>} KeysOfTypes
+ */
+
+/** @typedef {KeysOfTypes<RuleSetRule, RuleSetConditionOrConditions | RuleSetConditionOrConditionsAbsolute>} BasicMatcherRuleKeys */
+
 class BasicMatcherRulePlugin {
 	/**
-	 * @param {string} ruleProperty the rule property
+	 * @param {BasicMatcherRuleKeys} ruleProperty the rule property
 	 * @param {string=} dataProperty the data property
 	 * @param {boolean=} invert if true, inverts the condition
 	 */
@@ -31,11 +42,11 @@ class BasicMatcherRulePlugin {
 			(path, rule, unhandledProperties, result) => {
 				if (unhandledProperties.has(this.ruleProperty)) {
 					unhandledProperties.delete(this.ruleProperty);
-					const value =
-						rule[/** @type {keyof RuleSetRule} */ (this.ruleProperty)];
+					const value = rule[this.ruleProperty];
 					const condition = ruleSetCompiler.compileCondition(
 						`${path}.${this.ruleProperty}`,
-						value
+						/** @type {RuleSetConditionOrConditions | RuleSetConditionOrConditionsAbsolute} */
+						(value)
 					);
 					const fn = condition.fn;
 					result.conditions.push({

package/lib/rules/ObjectMatcherRulePlugin.js

@@ -5,14 +5,23 @@
 
 "use strict";
 
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetConditionOrConditions} RuleSetConditionOrConditions */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
 /** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
 /** @typedef {import("./RuleSetCompiler").RuleCondition} RuleCondition */
 /** @typedef {import("./RuleSetCompiler").RuleConditionFunction} RuleConditionFunction */
 
+/**
+ * @template T
+ * @template {T[keyof T]} V
+ * @typedef {import("./RuleSetCompiler").KeysOfTypes<T, V>} KeysOfTypes
+ */
+
+/** @typedef {KeysOfTypes<RuleSetRule, { [k: string]: RuleSetConditionOrConditions }>} ObjectMatcherRuleKeys */
+
 class ObjectMatcherRulePlugin {
 	/**
-	 * @param {string} ruleProperty the rule property
+	 * @param {ObjectMatcherRuleKeys} ruleProperty the rule property
 	 * @param {string=} dataProperty the data property
 	 * @param {RuleConditionFunction=} additionalConditionFunction need to check
 	 */
@@ -34,8 +43,8 @@ class ObjectMatcherRulePlugin {
 				if (unhandledProperties.has(ruleProperty)) {
 					unhandledProperties.delete(ruleProperty);
 					const value =
-						/** @type {Record<string, any>} */
-						(rule[/** @type {keyof RuleSetRule} */ (ruleProperty)]);
+						/** @type {Record<string, RuleSetConditionOrConditions>} */
+						(rule[ruleProperty]);
 					for (const property of Object.keys(value)) {
 						const nestedDataProperties = property.split(".");
 						const condition = ruleSetCompiler.compileCondition(

package/lib/rules/RuleSetCompiler.js

@@ -7,10 +7,13 @@
 
 const { SyncHook } = require("tapable");
 
+/** @typedef {import("../../declarations/WebpackOptions").Falsy} Falsy */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetLoaderOptions} RuleSetLoaderOptions */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
-/** @typedef {import("../../declarations/WebpackOptions").RuleSetRules} RuleSetRules */
 
-/** @typedef {function(string | EffectData): boolean} RuleConditionFunction */
+/** @typedef {(Falsy | RuleSetRule)[]} RuleSetRules */
+
+/** @typedef {(value: string | EffectData) => boolean} RuleConditionFunction */
 
 /**
  * @typedef {object} RuleCondition
@@ -32,7 +35,7 @@ const { SyncHook } = require("tapable");
 /**
  * @typedef {object} CompiledRule
  * @property {RuleCondition[]} conditions
- * @property {(Effect|function(EffectData): Effect[])[]} effects
+ * @property {(Effect | ((effectData: EffectData) => Effect[]))[]} effects
  * @property {CompiledRule[]=} rules
  * @property {CompiledRule[]=} oneOf
  */
@@ -40,16 +43,24 @@ const { SyncHook } = require("tapable");
 /**
  * @typedef {object} Effect
  * @property {string} type
- * @property {any} value
+ * @property {TODO} value
  */
 
+/** @typedef {Map<string, RuleSetLoaderOptions>} References */
+
 /**
  * @typedef {object} RuleSet
- * @property {Map<string, any>} references map of references in the rule set (may grow over time)
- * @property {function(EffectData): Effect[]} exec execute the rule set
+ * @property {References} references map of references in the rule set (may grow over time)
+ * @property {(effectData: EffectData) => Effect[]} exec execute the rule set
+ */
+
+/**
+ * @template T
+ * @template {T[keyof T]} V
+ * @typedef {({ [P in keyof Required<T>]: Required<T>[P] extends V ? P : never })[keyof T]} KeysOfTypes
  */
 
-/** @typedef {{ apply: (function(RuleSetCompiler): void) }} RuleSetPlugin */
+/** @typedef {{ apply: (ruleSetCompiler: RuleSetCompiler) => void }} RuleSetPlugin */
 
 class RuleSetCompiler {
 	/**
@@ -57,7 +68,7 @@ class RuleSetCompiler {
 	 */
 	constructor(plugins) {
 		this.hooks = Object.freeze({
-			/** @type {SyncHook<[string, RuleSetRule, Set<string>, CompiledRule, Map<string | undefined, any>]>} */
+			/** @type {SyncHook<[string, RuleSetRule, Set<string>, CompiledRule, References]>} */
 			rule: new SyncHook([
 				"path",
 				"rule",
@@ -74,7 +85,7 @@ class RuleSetCompiler {
 	}
 
 	/**
-	 * @param {TODO[]} ruleSet raw user provided rules
+	 * @param {RuleSetRules} ruleSet raw user provided rules
 	 * @returns {RuleSet} compiled RuleSet
 	 */
 	compile(ruleSet) {
@@ -161,7 +172,7 @@ class RuleSetCompiler {
 	/**
 	 * @param {string} path current path
 	 * @param {RuleSetRules} rules the raw rules provided by user
-	 * @param {Map<string, any>} refs references
+	 * @param {References} refs references
 	 * @returns {CompiledRule[]} rules
 	 */
 	compileRules(path, rules, refs) {
@@ -179,7 +190,7 @@ class RuleSetCompiler {
 	/**
 	 * @param {string} path current path
 	 * @param {RuleSetRule} rule the raw rule provided by user
-	 * @param {Map<string, any>} refs references
+	 * @param {References} refs references
 	 * @returns {CompiledRule} normalized and compiled rule for processing
 	 */
 	compileRule(path, rule, refs) {
@@ -228,7 +239,7 @@ class RuleSetCompiler {
 
 	/**
 	 * @param {string} path current path
-	 * @param {any} condition user provided condition value
+	 * @param {RuleSetLoaderOptions} condition user provided condition value
 	 * @returns {Condition} compiled condition
 	 */
 	compileCondition(path, condition) {
@@ -255,7 +266,7 @@ class RuleSetCompiler {
 			try {
 				return {
 					matchWhenEmpty: condition(""),
-					fn: condition
+					fn: /** @type {RuleConditionFunction} */ (condition)
 				};
 			} catch (_err) {
 				throw this.error(
@@ -386,7 +397,7 @@ class RuleSetCompiler {
 
 	/**
 	 * @param {string} path current path
-	 * @param {any} value value at the error location
+	 * @param {EXPECTED_ANY} value value at the error location
 	 * @param {string} message message explaining the problem
 	 * @returns {Error} an error object
 	 */