webpack 5.101.3 → 5.102.0

package/lib/optimize/SideEffectsFlagPlugin.js

@@ -21,7 +21,6 @@ const formatLocation = require("../formatLocation");
 /** @typedef {import("estree").ModuleDeclaration} ModuleDeclaration */
 /** @typedef {import("estree").Statement} Statement */
 /** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
@@ -37,11 +36,7 @@ const formatLocation = require("../formatLocation");
  * @property {boolean} checked if the export is conditional
  */
 
-/**
- * @typedef {object} ReexportInfo
- * @property {Map<string, ExportInModule[]>} static
- * @property {Map<Module, Set<string>>} dynamic
- */
+/** @typedef {string | boolean | string[] | undefined} SideEffectsFlagValue */
 
 /** @typedef {Map<string, RegExp>} CacheItem */
 
@@ -105,9 +100,7 @@ class SideEffectsFlagPlugin {
 							}
 							const hasSideEffects = SideEffectsFlagPlugin.moduleHasSideEffects(
 								resolveData.relativePath,
-								/** @type {string | boolean | string[] | undefined} */ (
-									sideEffects
-								),
+								/** @type {SideEffectsFlagValue} */ (sideEffects),
 								/** @type {CacheItem} */ (cache)
 							);
 							module.factoryMeta.sideEffectFree = !hasSideEffects;
@@ -397,7 +390,7 @@ class SideEffectsFlagPlugin {
 
 	/**
 	 * @param {string} moduleName the module name
-	 * @param {undefined | boolean | string | string[]} flagValue the flag value
+	 * @param {SideEffectsFlagValue} flagValue the flag value
 	 * @param {Map<string, RegExp>} cache cache for glob to regexp
 	 * @returns {boolean | undefined} true, when the module has side effects, undefined or false when not
 	 */

package/lib/optimize/SplitChunksPlugin.js

@@ -21,12 +21,11 @@ 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 */
 /** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksSizes} OptimizationSplitChunksSizes */
-/** @typedef {import("../../declarations/WebpackOptions").Output} OutputOptions */
+/** @typedef {import("../config/defaults").OutputNormalizedWithDefaults} OutputOptions */
 /** @typedef {import("../Chunk").ChunkName} ChunkName */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../ChunkGroup")} ChunkGroup */
@@ -37,10 +36,8 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 /** @typedef {import("../util/deterministicGrouping").GroupedItems<Module>} DeterministicGroupingGroupedItemsForModule */
 /** @typedef {import("../util/deterministicGrouping").Options<Module>} DeterministicGroupingOptionsForModule */
 
-/** @typedef {Record<string, number>} SplitChunksSizes */
-
 /**
- * @callback ChunkFilterFunction
+ * @callback ChunkFilterFn
  * @param {Chunk} chunk
  * @returns {boolean | undefined}
  */
@@ -52,12 +49,17 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @returns {number}
  */
 
+/** @typedef {string} SourceType */
+/** @typedef {SourceType[]} SourceTypes */
+/** @typedef {SourceType[]} DefaultSizeTypes */
+/** @typedef {Record<SourceType, number>} SplitChunksSizes */
+
 /**
  * @typedef {object} CacheGroupSource
  * @property {string} key
  * @property {number=} priority
- * @property {GetName=} getName
- * @property {ChunkFilterFunction=} chunksFilter
+ * @property {GetNameFn=} getName
+ * @property {ChunkFilterFn=} chunksFilter
  * @property {boolean=} enforce
  * @property {SplitChunksSizes} minSize
  * @property {SplitChunksSizes} minSizeReduction
@@ -79,8 +81,8 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @typedef {object} CacheGroup
  * @property {string} key
  * @property {number} priority
- * @property {GetName=} getName
- * @property {ChunkFilterFunction} chunksFilter
+ * @property {GetNameFn=} getName
+ * @property {ChunkFilterFn} chunksFilter
  * @property {SplitChunksSizes} minSize
  * @property {SplitChunksSizes} minSizeReduction
  * @property {SplitChunksSizes} minRemainingSize
@@ -103,7 +105,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 
 /**
  * @typedef {object} FallbackCacheGroup
- * @property {ChunkFilterFunction} chunksFilter
+ * @property {ChunkFilterFn} chunksFilter
  * @property {SplitChunksSizes} minSize
  * @property {SplitChunksSizes} maxAsyncSize
  * @property {SplitChunksSizes} maxInitialSize
@@ -124,17 +126,17 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  */
 
 /**
- * @callback GetName
+ * @callback GetNameFn
  * @param {Module} module
  * @param {Chunk[]} chunks
  * @param {string} key
- * @returns {string=}
+ * @returns {string | undefined}
  */
 
 /**
  * @typedef {object} SplitChunksOptions
- * @property {ChunkFilterFunction} chunksFilter
- * @property {string[]} defaultSizeTypes
+ * @property {ChunkFilterFn} chunksFilter
+ * @property {DefaultSizeTypes} defaultSizeTypes
  * @property {SplitChunksSizes} minSize
  * @property {SplitChunksSizes} minSizeReduction
  * @property {SplitChunksSizes} minRemainingSize
@@ -148,7 +150,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {TemplatePath=} filename
  * @property {string} automaticNameDelimiter
  * @property {GetCacheGroups} getCacheGroups
- * @property {GetName} getName
+ * @property {GetNameFn} getName
  * @property {boolean} usedExports
  * @property {FallbackCacheGroup} fallbackCacheGroup
  */
@@ -159,13 +161,13 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {CacheGroup} cacheGroup
  * @property {number} cacheGroupIndex
  * @property {string=} name
- * @property {Record<string, number>} sizes
+ * @property {Record<SourceType, number>} sizes
  * @property {Set<Chunk>} chunks
  * @property {Set<Chunk>} reusableChunks
  * @property {Set<bigint | Chunk>} chunksKeys
  */
 
-/** @type {GetName} */
+/** @type {GetNameFn} */
 const defaultGetName = () => undefined;
 
 const deterministicGroupingForModules =
@@ -184,7 +186,7 @@ const hashFilename = (name, outputOptions) => {
 	const digest =
 		/** @type {string} */
 		(
-			createHash(/** @type {HashFunction} */ (outputOptions.hashFunction))
+			createHash(outputOptions.hashFunction)
 				.update(name)
 				.digest(outputOptions.hashDigest)
 		);
@@ -286,7 +288,7 @@ const ALL_CHUNK_FILTER = (_chunk) => true;
 
 /**
  * @param {OptimizationSplitChunksSizes | undefined} value the sizes
- * @param {string[]} defaultSizeTypes the default size types
+ * @param {DefaultSizeTypes} defaultSizeTypes the default size types
  * @returns {SplitChunksSizes} normalized representation
  */
 const normalizeSizes = (value, defaultSizeTypes) => {
@@ -379,7 +381,7 @@ const checkMinSizeReduction = (sizes, minSizeReduction, chunkCount) => {
 /**
  * @param {SplitChunksSizes} sizes the sizes
  * @param {SplitChunksSizes} minSize the min sizes
- * @returns {undefined | string[]} list of size types that are below min size
+ * @returns {undefined | SourceTypes} list of size types that are below min size
  */
 const getViolatingMinSizes = (sizes, minSize) => {
 	let list;
@@ -408,20 +410,20 @@ const totalSize = (sizes) => {
 
 /**
  * @param {OptimizationSplitChunksCacheGroup["name"]} name the chunk name
- * @returns {GetName | undefined} a function to get the name of the chunk
+ * @returns {GetNameFn | undefined} a function to get the name of the chunk
  */
 const normalizeName = (name) => {
 	if (typeof name === "string") {
 		return () => name;
 	}
 	if (typeof name === "function") {
-		return /** @type {GetName} */ (name);
+		return /** @type {GetNameFn} */ (name);
 	}
 };
 
 /**
  * @param {OptimizationSplitChunksCacheGroup["chunks"]} chunks the chunk filter option
- * @returns {ChunkFilterFunction | undefined} the chunk filter function
+ * @returns {ChunkFilterFn | undefined} the chunk filter function
  */
 const normalizeChunksFilter = (chunks) => {
 	if (chunks === "initial") {
@@ -443,7 +445,7 @@ const normalizeChunksFilter = (chunks) => {
 
 /**
  * @param {undefined | GetCacheGroups | Record<string, false | string | RegExp | OptimizationSplitChunksGetCacheGroups | OptimizationSplitChunksCacheGroup>} cacheGroups the cache group options
- * @param {string[]} defaultSizeTypes the default size types
+ * @param {DefaultSizeTypes} defaultSizeTypes the default size types
  * @returns {GetCacheGroups} a function to get the cache groups
  */
 const normalizeCacheGroups = (cacheGroups, defaultSizeTypes) => {
@@ -586,7 +588,7 @@ const checkModuleLayer = (test, module) => {
 /**
  * @param {OptimizationSplitChunksCacheGroup} options the group options
  * @param {string} key key of cache group
- * @param {string[]} defaultSizeTypes the default size types
+ * @param {DefaultSizeTypes} defaultSizeTypes the default size types
  * @returns {CacheGroupSource} the normalized cached group
  */
 const createCacheGroupSource = (options, key, defaultSizeTypes) => {
@@ -653,7 +655,7 @@ module.exports = class SplitChunksPlugin {
 		/** @type {SplitChunksOptions} */
 		this.options = {
 			chunksFilter:
-				/** @type {ChunkFilterFunction} */
+				/** @type {ChunkFilterFn} */
 				(normalizeChunksFilter(options.chunks || "all")),
 			defaultSizeTypes,
 			minSize,
@@ -684,13 +686,13 @@ module.exports = class SplitChunksPlugin {
 				defaultSizeTypes
 			),
 			getName: options.name
-				? /** @type {GetName} */ (normalizeName(options.name))
+				? /** @type {GetNameFn} */ (normalizeName(options.name))
 				: defaultGetName,
 			automaticNameDelimiter: options.automaticNameDelimiter || "-",
 			usedExports: options.usedExports || false,
 			fallbackCacheGroup: {
 				chunksFilter:
-					/** @type {ChunkFilterFunction} */
+					/** @type {ChunkFilterFn} */
 					(
 						normalizeChunksFilter(
 							fallbackCacheGroup.chunks || options.chunks || "all"
@@ -947,15 +949,17 @@ module.exports = class SplitChunksPlugin {
 						return { chunkSetsInGraph, singleChunkSets };
 					});
 
+					/** @typedef {Map<number, Set<Chunk>[]>} ChunkSetsByCount */
+
 					// group these set of chunks by count
 					// to allow to check less sets via isSubset
 					// (only smaller sets can be subset)
 					/**
 					 * @param {IterableIterator<Set<Chunk>>} chunkSets set of sets of chunks
-					 * @returns {Map<number, Array<Set<Chunk>>>} map of sets of chunks by count
+					 * @returns {ChunkSetsByCount} map of sets of chunks by count
 					 */
 					const groupChunkSetsByCount = (chunkSets) => {
-						/** @type {Map<number, Array<Set<Chunk>>>} */
+						/** @type {ChunkSetsByCount} */
 						const chunkSetsByCount = new Map();
 						for (const chunksSet of chunkSets) {
 							const count = chunksSet.size;
@@ -979,19 +983,21 @@ module.exports = class SplitChunksPlugin {
 						)
 					);
 
+					/** @typedef {(Set<Chunk> | Chunk)[]} Combinations */
+
 					// 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
+					 * @returns {(key: bigint | Chunk) => Combinations} combinations
 					 */
 					const createGetCombinations = (
 						chunkSets,
 						singleChunkSets,
 						chunkSetsByCount
 					) => {
-						/** @type {Map<bigint | Chunk, (Set<Chunk> | Chunk)[]>} */
+						/** @type {Map<bigint | Chunk, Combinations>} */
 						const combinationsCache = new Map();
 
 						return (key) => {
@@ -1005,7 +1011,7 @@ module.exports = class SplitChunksPlugin {
 							const chunksSet =
 								/** @type {Set<Chunk>} */
 								(chunkSets.get(key));
-							/** @type {(Set<Chunk> | Chunk)[]} */
+							/** @type {Combinations} */
 							const array = [chunksSet];
 							for (const [count, setArray] of chunkSetsByCount) {
 								// "equal" is not needed because they would have been merge in the first step
@@ -1038,7 +1044,7 @@ module.exports = class SplitChunksPlugin {
 
 					/**
 					 * @param {bigint | Chunk} key key
-					 * @returns {(Set<Chunk> | Chunk)[]} combinations by key
+					 * @returns {Combinations} combinations by key
 					 */
 					const getCombinations = (key) => getCombinationsFactory()(key);
 
@@ -1053,7 +1059,7 @@ module.exports = class SplitChunksPlugin {
 					});
 					/**
 					 * @param {bigint | Chunk} key key
-					 * @returns {(Set<Chunk> | Chunk)[]} exports combinations by key
+					 * @returns {Combinations} exports combinations by key
 					 */
 					const getExportsCombinations = (key) =>
 						getExportsCombinationsFactory()(key);
@@ -1064,14 +1070,14 @@ module.exports = class SplitChunksPlugin {
 					 * @property {bigint | Chunk} key a key of the list
 					 */
 
-					/** @type {WeakMap<Set<Chunk> | Chunk, WeakMap<ChunkFilterFunction, SelectedChunksResult>>} */
+					/** @type {WeakMap<Set<Chunk> | Chunk, WeakMap<ChunkFilterFn, SelectedChunksResult>>} */
 					const selectedChunksCacheByChunksSet = new WeakMap();
 
 					/**
 					 * get list and key by applying the filter function to the list
 					 * It is cached for performance reasons
 					 * @param {Set<Chunk> | Chunk} chunks list of chunks
-					 * @param {ChunkFilterFunction} chunkFilter filter function for chunks
+					 * @param {ChunkFilterFn} chunkFilter filter function for chunks
 					 * @returns {SelectedChunksResult} list and key
 					 */
 					const getSelectedChunks = (chunks, chunkFilter) => {
@@ -1132,7 +1138,7 @@ module.exports = class SplitChunksPlugin {
 						// Determine name for split chunk
 
 						const name =
-							/** @type {GetName} */
+							/** @type {GetNameFn} */
 							(cacheGroup.getName)(module, selectedChunks, cacheGroup.key);
 						// Check if the name is ok
 						const existingChunk = name && compilation.namedChunks.get(name);
@@ -1294,7 +1300,7 @@ module.exports = class SplitChunksPlugin {
 								const { chunks: selectedChunks, key: selectedChunksKey } =
 									getSelectedChunks(
 										chunkCombination,
-										/** @type {ChunkFilterFunction} */
+										/** @type {ChunkFilterFn} */
 										(cacheGroup.chunksFilter)
 									);
 
@@ -1316,7 +1322,7 @@ module.exports = class SplitChunksPlugin {
 
 					/**
 					 * @param {ChunksInfoItem} info entry
-					 * @param {string[]} sourceTypes source types to be removed
+					 * @param {SourceTypes} sourceTypes source types to be removed
 					 */
 					const removeModulesWithSourceType = (info, sourceTypes) => {
 						for (const module of info.modules) {

package/lib/performance/SizeLimitsPlugin.js

@@ -31,6 +31,7 @@ const NoAsyncChunksWarning = require("./NoAsyncChunksWarning");
  * @property {string[]} files
  */
 
+/** @type {WeakSet<Entrypoint | ChunkGroup | Source>} */
 const isOverSizeLimitSet = new WeakSet();
 
 /**
@@ -55,7 +56,7 @@ module.exports = class SizeLimitsPlugin {
 	}
 
 	/**
-	 * @param {ChunkGroup | Source} thing the resource to test
+	 * @param {Entrypoint | ChunkGroup | Source} thing the resource to test
 	 * @returns {boolean} true if over the limit
 	 */
 	static isOverSizeLimit(thing) {

package/lib/prefetch/ChunkPrefetchFunctionRuntimeModule.js

@@ -8,17 +8,15 @@ const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
 /** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 
 class ChunkPrefetchFunctionRuntimeModule extends RuntimeModule {
 	/**
-	 * @param {string} childType TODO
-	 * @param {string} runtimeFunction TODO
-	 * @param {string} runtimeHandlers TODO
+	 * @param {"prefetch" | "preload"} type "prefetch" or "preload" chunk type function
+	 * @param {string} runtimeFunction the runtime function name
+	 * @param {string} runtimeHandlers the runtime handlers
 	 */
-	constructor(childType, runtimeFunction, runtimeHandlers) {
-		super(`chunk ${childType} function`);
-		this.childType = childType;
+	constructor(type, runtimeFunction, runtimeHandlers) {
+		super(`chunk ${type} function`);
 		this.runtimeFunction = runtimeFunction;
 		this.runtimeHandlers = runtimeHandlers;
 	}

package/lib/prefetch/ChunkPrefetchPreloadPlugin.js

@@ -11,8 +11,6 @@ const ChunkPrefetchStartupRuntimeModule = require("./ChunkPrefetchStartupRuntime
 const ChunkPrefetchTriggerRuntimeModule = require("./ChunkPrefetchTriggerRuntimeModule");
 const ChunkPreloadTriggerRuntimeModule = require("./ChunkPreloadTriggerRuntimeModule");
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGroup").RawChunkGroupOptions} RawChunkGroupOptions */
 /** @typedef {import("../Compiler")} Compiler */
 
 const PLUGIN_NAME = "ChunkPrefetchPreloadPlugin";

package/lib/prefetch/ChunkPrefetchStartupRuntimeModule.js

@@ -10,7 +10,6 @@ const Template = require("../Template");
 
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 
 class ChunkPrefetchStartupRuntimeModule extends RuntimeModule {
 	/**

package/lib/prefetch/ChunkPrefetchTriggerRuntimeModule.js

@@ -9,11 +9,11 @@ const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
 /** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../Chunk").ChunkChildIdsByOrdersMap} ChunkChildIdsByOrdersMap */
 
 class ChunkPrefetchTriggerRuntimeModule extends RuntimeModule {
 	/**
-	 * @param {Record<string|number, (string|number)[]>} chunkMap map from chunk to
+	 * @param {ChunkChildIdsByOrdersMap} chunkMap map from chunk to
 	 */
 	constructor(chunkMap) {
 		super("chunk prefetch trigger", RuntimeModule.STAGE_TRIGGER);

package/lib/prefetch/ChunkPreloadTriggerRuntimeModule.js

@@ -9,11 +9,11 @@ const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
 /** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../Chunk").ChunkChildIdsByOrdersMap} ChunkChildIdsByOrdersMap */
 
 class ChunkPreloadTriggerRuntimeModule extends RuntimeModule {
 	/**
-	 * @param {Record<string|number, (string|number)[]>} chunkMap map from chunk to chunks
+	 * @param {ChunkChildIdsByOrdersMap} chunkMap map from chunk to chunks
 	 */
 	constructor(chunkMap) {
 		super("chunk preload trigger", RuntimeModule.STAGE_TRIGGER);

package/lib/rules/BasicMatcherRulePlugin.js

@@ -7,10 +7,8 @@
 
 /** @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

package/lib/rules/ObjectMatcherRulePlugin.js

@@ -9,7 +9,6 @@
 /** @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 */
 
 /**

package/lib/rules/RuleSetCompiler.js

@@ -7,10 +7,10 @@
 
 const { SyncHook } = require("tapable");
 
+/** @typedef {import("enhanced-resolve").ResolveRequest} ResolveRequest */
 /** @typedef {import("../../declarations/WebpackOptions").Falsy} Falsy */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetLoaderOptions} RuleSetLoaderOptions */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
-/** @typedef {import("../NormalModule").LoaderItem} LoaderItem */
 
 /** @typedef {(Falsy | RuleSetRule)[]} RuleSetRules */
 
@@ -38,10 +38,10 @@ const { SyncHook } = require("tapable");
  * @property {string=} resourceQuery
  * @property {string=} resourceFragment
  * @property {string=} scheme
- * @property {ImportAttributes=} assertions
+ * @property {ImportAttributes=} attributes
  * @property {string=} mimetype
  * @property {string} dependency
- * @property {Record<string, EXPECTED_ANY>=} descriptionData
+ * @property {ResolveRequest["descriptionFileData"]=} descriptionData
  * @property {string=} compiler
  * @property {string} issuer
  * @property {string} issuerLayer
@@ -85,6 +85,8 @@ const { SyncHook } = require("tapable");
  * @typedef {({ [P in keyof Required<T>]: Required<T>[P] extends V ? P : never })[keyof T]} KeysOfTypes
  */
 
+/** @typedef {Set<string>} UnhandledProperties */
+
 /** @typedef {{ apply: (ruleSetCompiler: RuleSetCompiler) => void }} RuleSetPlugin */
 
 class RuleSetCompiler {
@@ -93,7 +95,7 @@ class RuleSetCompiler {
 	 */
 	constructor(plugins) {
 		this.hooks = Object.freeze({
-			/** @type {SyncHook<[string, RuleSetRule, Set<string>, CompiledRule, References]>} */
+			/** @type {SyncHook<[string, RuleSetRule, UnhandledProperties, CompiledRule, References]>} */
 			rule: new SyncHook([
 				"path",
 				"rule",
@@ -127,7 +129,7 @@ class RuleSetCompiler {
 			for (const condition of rule.conditions) {
 				const p = condition.property;
 				if (Array.isArray(p)) {
-					/** @type {EffectData | EffectData[keyof EffectData] | undefined} */
+					/** @type {EXPECTED_ANY} */
 					let current = data;
 					for (const subProperty of p) {
 						if (
@@ -219,7 +221,7 @@ class RuleSetCompiler {
 	 * @returns {CompiledRule} normalized and compiled rule for processing
 	 */
 	compileRule(path, rule, refs) {
-		/** @type {Set<string>} */
+		/** @type {UnhandledProperties} */
 		const unhandledProperties = new Set(
 			Object.keys(rule).filter(
 				(key) => rule[/** @type {keyof RuleSetRule} */ (key)] !== undefined

package/lib/runtime/BaseUriRuntimeModule.js

@@ -8,7 +8,7 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 
-/** @typedef {import("../../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescriptionNormalized */
+/** @typedef {import("../../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescription */
 /** @typedef {import("../Chunk")} Chunk */
 
 class BaseUriRuntimeModule extends RuntimeModule {
@@ -22,7 +22,7 @@ class BaseUriRuntimeModule extends RuntimeModule {
 	generate() {
 		const chunk = /** @type {Chunk} */ (this.chunk);
 		const options =
-			/** @type {EntryDescriptionNormalized} */
+			/** @type {EntryDescription} */
 			(chunk.getEntryOptions());
 		return `${RuntimeGlobals.baseURI} = ${
 			options.baseUri === undefined

package/lib/runtime/CompatRuntimeModule.js

@@ -10,7 +10,6 @@ const RuntimeModule = require("../RuntimeModule");
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../MainTemplate")} MainTemplate */
 
 class CompatRuntimeModule extends RuntimeModule {
 	constructor() {

package/lib/runtime/GetChunkFilenameRuntimeModule.js

@@ -13,7 +13,6 @@ const { first } = require("../util/SetHelpers");
 /** @typedef {import("../Chunk").ChunkId} ChunkId */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Compilation").AssetInfo} AssetInfo */
 /** @typedef {import("../TemplatedPathPlugin").TemplatePath} TemplatePath */
 
 class GetChunkFilenameRuntimeModule extends RuntimeModule {
@@ -125,7 +124,7 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 		 */
 		const addStaticUrl = (c, chunkFilename) => {
 			/**
-			 * @param {string | number} value a value
+			 * @param {ChunkId} value a value
 			 * @returns {string} string to put in quotes
 			 */
 			const unquotedStringify = (value) => {
@@ -194,10 +193,10 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 		 * @returns {string} code with static mapping of results of fn
 		 */
 		const createMap = (fn) => {
-			/** @type {Record<number | string, number | string>} */
+			/** @type {Record<ChunkId, ChunkId>} */
 			const obj = {};
 			let useId = false;
-			/** @type {number | string | undefined} */
+			/** @type {ChunkId | undefined} */
 			let lastKey;
 			let entries = 0;
 			for (const c of dynamicUrlChunks) {
@@ -205,8 +204,8 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 				if (value === c.id) {
 					useId = true;
 				} else {
-					obj[/** @type {number | string} */ (c.id)] = value;
-					lastKey = /** @type {number | string} */ (c.id);
+					obj[/** @type {ChunkId} */ (c.id)] = value;
+					lastKey = /** @type {ChunkId} */ (c.id);
 					entries++;
 				}
 			}
@@ -214,9 +213,9 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 			if (entries === 1) {
 				return useId
 					? `(chunkId === ${JSON.stringify(lastKey)} ? ${JSON.stringify(
-							obj[/** @type {number | string} */ (lastKey)]
+							obj[/** @type {ChunkId} */ (lastKey)]
 						)} : chunkId)`
-					: JSON.stringify(obj[/** @type {number | string} */ (lastKey)]);
+					: JSON.stringify(obj[/** @type {ChunkId} */ (lastKey)]);
 			}
 			return useId
 				? `(${JSON.stringify(obj)}[chunkId] || chunkId)`
@@ -248,7 +247,7 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 					hashWithLength: mapExprWithLength(
 						(c) => /** @type {string} */ (c.renderedHash)
 					),
-					name: mapExpr((c) => c.name || /** @type {number | string} */ (c.id)),
+					name: mapExpr((c) => c.name || /** @type {ChunkId} */ (c.id)),
 					contentHash: {
 						[contentType]: mapExpr((c) => c.contentHash[contentType])
 					},

package/lib/runtime/LoadScriptRuntimeModule.js

@@ -11,7 +11,6 @@ const Template = require("../Template");
 const HelperRuntimeModule = require("./HelperRuntimeModule");
 
 /** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
 
 /**
  * @typedef {object} LoadScriptCompilationHooks
@@ -74,7 +73,6 @@ class LoadScriptRuntimeModule extends HelperRuntimeModule {
 			"script = document.createElement('script');",
 			scriptType ? `script.type = ${JSON.stringify(scriptType)};` : "",
 			charset ? "script.charset = 'utf-8';" : "",
-			`script.timeout = ${/** @type {number} */ (loadTimeout) / 1000};`,
 			`if (${RuntimeGlobals.scriptNonce}) {`,
 			Template.indent(
 				`script.setAttribute("nonce", ${RuntimeGlobals.scriptNonce});`

package/lib/runtime/MakeDeferredNamespaceObjectRuntime.js

@@ -174,7 +174,7 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 				])},`,
 				`ownKeys: ${runtimeTemplate.basicFunction("", [
 					init,
-					`var keys = Reflect.ownKeys(ns).filter(${runtimeTemplate.expressionFunction('x !== "then"', "x")}).concat([Symbol.toStringTag]);`,
+					`var keys = Reflect.ownKeys(ns).filter(${runtimeTemplate.expressionFunction('x !== "then" && x !== Symbol.toStringTag', "x")}).concat([Symbol.toStringTag]);`,
 					"return keys;"
 				])},`,
 				`getOwnPropertyDescriptor: ${runtimeTemplate.basicFunction("_, name", [

package/lib/runtime/PublicPathRuntimeModule.js

@@ -7,12 +7,12 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 
-/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} OutputOptions */
+/** @typedef {import("../../declarations/WebpackOptions").PublicPath} PublicPath */
 /** @typedef {import("../Compilation")} Compilation */
 
 class PublicPathRuntimeModule extends RuntimeModule {
 	/**
-	 * @param {OutputOptions["publicPath"]} publicPath public path
+	 * @param {PublicPath} publicPath public path
 	 */
 	constructor(publicPath) {
 		super("publicPath", RuntimeModule.STAGE_BASIC);