webpack 5.93.0 → 5.94.0

package/lib/optimize/LimitChunkCountPlugin.js

@@ -119,7 +119,7 @@ class LimitChunkCountPlugin {
 					/** @type {Map<Chunk, Set<ChunkCombination>>} */
 					const combinationsByChunk = new Map();
 
-					orderedChunks.forEach((b, bIdx) => {
+					for (const [bIdx, b] of orderedChunks.entries()) {
 						// create combination pairs with size and integrated size
 						for (let aIdx = 0; aIdx < bIdx; aIdx++) {
 							const a = orderedChunks[aIdx];
@@ -149,8 +149,7 @@ class LimitChunkCountPlugin {
 							addToSetMap(combinationsByChunk, a, c);
 							addToSetMap(combinationsByChunk, b, c);
 						}
-						return combinations;
-					});
+					}
 
 					// list of modified chunks during this run
 					// combinations affected by this change are skipped to allow

package/lib/optimize/MangleExportsPlugin.js

@@ -149,6 +149,7 @@ class MangleExportsPlugin {
 	constructor(deterministic) {
 		this._deterministic = deterministic;
 	}
+
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance

package/lib/optimize/MinMaxSizeWarning.js

@@ -23,7 +23,7 @@ class MinMaxSizeWarning extends WebpackError {
 					: `Cache group ${keys[0]}`;
 		}
 		super(
-			`SplitChunksPlugin\n` +
+			"SplitChunksPlugin\n" +
 				`${keysMessage}\n` +
 				`Configured minSize (${SizeFormatHelpers.formatSize(minSize)}) is ` +
 				`bigger than maxSize (${SizeFormatHelpers.formatSize(maxSize)}).\n` +

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -45,19 +45,9 @@ const ConcatenatedModule = require("./ConcatenatedModule");
  * @param {string} msg message
  * @returns {string} formatted message
  */
-const formatBailoutReason = msg => {
-	return "ModuleConcatenation bailout: " + msg;
-};
+const formatBailoutReason = msg => `ModuleConcatenation bailout: ${msg}`;
 
 class ModuleConcatenationPlugin {
-	/**
-	 * @param {TODO} options options
-	 */
-	constructor(options) {
-		if (typeof options !== "object") options = {};
-		this.options = options;
-	}
-
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
@@ -130,15 +120,14 @@ class ModuleConcatenationPlugin {
 							requestShortener
 						)}${reasonWithPrefix}`
 					);
-				} else {
-					return formatBailoutReason(
-						`Cannot concat with ${module.readableIdentifier(
-							requestShortener
-						)} because of ${problem.readableIdentifier(
-							requestShortener
-						)}${reasonWithPrefix}`
-					);
 				}
+				return formatBailoutReason(
+					`Cannot concat with ${module.readableIdentifier(
+						requestShortener
+					)} because of ${problem.readableIdentifier(
+						requestShortener
+					)}${reasonWithPrefix}`
+				);
 			};
 
 			compilation.hooks.optimizeChunkModules.tapAsync(
@@ -170,13 +159,13 @@ class ModuleConcatenationPlugin {
 
 						// Must not be an async module
 						if (moduleGraph.isAsync(module)) {
-							setBailoutReason(module, `Module is async`);
+							setBailoutReason(module, "Module is async");
 							continue;
 						}
 
 						// Must be in strict mode
 						if (!(/** @type {BuildInfo} */ (module.buildInfo).strict)) {
-							setBailoutReason(module, `Module is not in strict mode`);
+							setBailoutReason(module, "Module is not in strict mode");
 							continue;
 						}
 
@@ -189,11 +178,10 @@ class ModuleConcatenationPlugin {
 						// Exports must be known (and not dynamic)
 						const exportsInfo = moduleGraph.getExportsInfo(module);
 						const relevantExports = exportsInfo.getRelevantExports(undefined);
-						const unknownReexports = relevantExports.filter(exportInfo => {
-							return (
+						const unknownReexports = relevantExports.filter(
+							exportInfo =>
 								exportInfo.isReexport() && !exportInfo.getTarget(moduleGraph)
-							);
-						});
+						);
 						if (unknownReexports.length > 0) {
 							setBailoutReason(
 								module,
@@ -210,9 +198,7 @@ class ModuleConcatenationPlugin {
 
 						// Root modules must have a static list of exports
 						const unknownProvidedExports = relevantExports.filter(
-							exportInfo => {
-								return exportInfo.provided !== true;
-							}
+							exportInfo => exportInfo.provided !== true
 						);
 						if (unknownProvidedExports.length > 0) {
 							setBailoutReason(
@@ -245,12 +231,11 @@ class ModuleConcatenationPlugin {
 					// modules with lower depth are more likely suited as roots
 					// this improves performance, because modules already selected as inner are skipped
 					logger.time("sort relevant modules");
-					relevantModules.sort((a, b) => {
-						return (
+					relevantModules.sort(
+						(a, b) =>
 							/** @type {number} */ (moduleGraph.getDepth(a)) -
 							/** @type {number} */ (moduleGraph.getDepth(b))
-						);
-					});
+					);
 					logger.timeEnd("sort relevant modules");
 
 					/** @type {Statistics} */
@@ -279,7 +264,7 @@ class ModuleConcatenationPlugin {
 						// TODO reconsider that when it's only used in a different runtime
 						if (usedAsInner.has(currentRoot)) continue;
 
-						let chunkRuntime = undefined;
+						let chunkRuntime;
 						for (const r of chunkGraph.getModuleRuntimes(currentRoot)) {
 							chunkRuntime = mergeRuntimeOwned(chunkRuntime, r);
 						}
@@ -376,11 +361,9 @@ class ModuleConcatenationPlugin {
 					// to get the biggest groups possible. Used modules are marked with usedModules
 					// TODO: Allow to reuse existing configuration while trying to add dependencies.
 					// This would improve performance. O(n^2) -> O(n)
-					logger.time(`sort concat configurations`);
-					concatConfigurations.sort((a, b) => {
-						return b.modules.size - a.modules.size;
-					});
-					logger.timeEnd(`sort concat configurations`);
+					logger.time("sort concat configurations");
+					concatConfigurations.sort((a, b) => b.modules.size - a.modules.size);
+					logger.timeEnd("sort concat configurations");
 					const usedModules = new Set();
 
 					logger.time("create concatenated modules");
@@ -399,7 +382,7 @@ class ModuleConcatenationPlugin {
 
 							// Create a new ConcatenatedModule
 							ConcatenatedModule.getCompilationHooks(compilation);
-							let newModule = ConcatenatedModule.create(
+							const newModule = ConcatenatedModule.create(
 								rootModule,
 								modules,
 								concatConfiguration.runtime,
@@ -448,15 +431,12 @@ class ModuleConcatenationPlugin {
 										moduleGraph.copyOutgoingModuleConnections(
 											m,
 											newModule,
-											c => {
-												return (
-													c.originModule === m &&
-													!(
-														c.dependency instanceof HarmonyImportDependency &&
-														modules.has(c.module)
-													)
-												);
-											}
+											c =>
+												c.originModule === m &&
+												!(
+													c.dependency instanceof HarmonyImportDependency &&
+													modules.has(c.module)
+												)
 										);
 										// remove module from chunk
 										for (const chunk of chunkGraph.getModuleChunksIterable(
@@ -639,11 +619,11 @@ class ModuleConcatenationPlugin {
 			incomingConnections.get(null) || incomingConnections.get(undefined);
 		if (incomingConnectionsFromNonModules) {
 			const activeNonModulesConnections =
-				incomingConnectionsFromNonModules.filter(connection => {
+				incomingConnectionsFromNonModules.filter(connection =>
 					// We are not interested in inactive connections
 					// or connections without dependency
-					return connection.isActive(runtime);
-				});
+					connection.isActive(runtime)
+				);
 			if (activeNonModulesConnections.length > 0) {
 				/**
 				 * @param {RequestShortener} requestShortener request shortener
@@ -676,7 +656,7 @@ class ModuleConcatenationPlugin {
 				if (chunkGraph.getNumberOfModuleChunks(originModule) === 0) continue;
 
 				// We don't care for connections from other runtimes
-				let originRuntime = undefined;
+				let originRuntime;
 				for (const r of chunkGraph.getModuleRuntimes(originModule)) {
 					originRuntime = mergeRuntimeOwned(originRuntime, r);
 				}
@@ -743,19 +723,20 @@ class ModuleConcatenationPlugin {
 			 */
 			const problem = requestShortener => {
 				const names = Array.from(nonHarmonyConnections)
-					.map(([originModule, connections]) => {
-						return `${originModule.readableIdentifier(
-							requestShortener
-						)} (referenced with ${Array.from(
-							new Set(
-								connections
-									.map(c => c.dependency && c.dependency.type)
-									.filter(Boolean)
+					.map(
+						([originModule, connections]) =>
+							`${originModule.readableIdentifier(
+								requestShortener
+							)} (referenced with ${Array.from(
+								new Set(
+									connections
+										.map(c => c.dependency && c.dependency.type)
+										.filter(Boolean)
+								)
 							)
-						)
-							.sort()
-							.join(", ")})`;
-					})
+								.sort()
+								.join(", ")})`
+					)
 					.sort();
 				return `Module ${module.readableIdentifier(
 					requestShortener
@@ -779,19 +760,15 @@ class ModuleConcatenationPlugin {
 				/** @type {false | RuntimeSpec} */
 				let currentRuntimeCondition = false;
 				for (const connection of connections) {
-					const runtimeCondition = filterRuntime(runtime, runtime => {
-						return connection.isTargetActive(runtime);
-					});
+					const runtimeCondition = filterRuntime(runtime, runtime =>
+						connection.isTargetActive(runtime)
+					);
 					if (runtimeCondition === false) continue;
 					if (runtimeCondition === true) continue outer;
-					if (currentRuntimeCondition !== false) {
-						currentRuntimeCondition = mergeRuntime(
-							currentRuntimeCondition,
-							runtimeCondition
-						);
-					} else {
-						currentRuntimeCondition = runtimeCondition;
-					}
+					currentRuntimeCondition =
+						currentRuntimeCondition !== false
+							? mergeRuntime(currentRuntimeCondition, runtimeCondition)
+							: runtimeCondition;
 				}
 				if (currentRuntimeCondition !== false) {
 					otherRuntimeConnections.push({
@@ -805,8 +782,8 @@ class ModuleConcatenationPlugin {
 				 * @param {RequestShortener} requestShortener request shortener
 				 * @returns {string} problem description
 				 */
-				const problem = requestShortener => {
-					return `Module ${module.readableIdentifier(
+				const problem = requestShortener =>
+					`Module ${module.readableIdentifier(
 						requestShortener
 					)} is runtime-dependent referenced by these modules: ${Array.from(
 						otherRuntimeConnections,
@@ -819,7 +796,6 @@ class ModuleConcatenationPlugin {
 								/** @type {RuntimeSpec} */ (runtimeCondition)
 							)})`
 					).join(", ")}`;
-				};
 				statistics.incorrectRuntimeCondition++;
 				failureCache.set(module, problem); // cache failures for performance
 				return problem;

package/lib/optimize/RealContentHashPlugin.js

@@ -61,9 +61,7 @@ const mapAndDeduplicateBuffers = (input, fn) => {
  * @param {string} str String to quote
  * @returns {string} Escaped string
  */
-const quoteMeta = str => {
-	return str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
-};
+const quoteMeta = str => str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
 
 const cachedSourceMap = new WeakMap();
 
@@ -215,7 +213,7 @@ class RealContentHashPlugin {
 							[asset.referencedHashes, asset.ownHashes] =
 								await cacheAnalyse.providePromise(name, etag, () => {
 									const referencedHashes = new Set();
-									let ownHashes = new Set();
+									const ownHashes = new Set();
 									const inContent = content.match(hashRegExp);
 									if (inContent) {
 										for (const hash of inContent) {
@@ -256,7 +254,7 @@ ${referencingAssets
 	})
 	.join("\n")}`);
 							compilation.errors.push(err);
-							return undefined;
+							return;
 						}
 						const hashes = new Set();
 						for (const { referencedHashes, ownHashes } of assets) {
@@ -369,7 +367,7 @@ ${referencingAssets
 									(asset.referencedHashes)
 								).some(hash => hashToNewHash.get(hash) !== hash)
 							) {
-								const identifier = asset.name + "|without-own";
+								const identifier = `${asset.name}|without-own`;
 								const etag = getEtag(asset);
 								asset.newSourceWithoutOwn = await cacheGenerate.providePromise(
 									identifier,
@@ -410,11 +408,10 @@ ${referencingAssets
 								return asset.newSourceWithoutOwn
 									? asset.newSourceWithoutOwn.buffer()
 									: asset.source.buffer();
-							} else {
-								return asset.newSource
-									? asset.newSource.buffer()
-									: asset.source.buffer();
 							}
+							return asset.newSource
+								? asset.newSource.buffer()
+								: asset.source.buffer();
 						});
 						let newHash = hooks.updateHash.call(assetsContent, oldHash);
 						if (!newHash) {

package/lib/optimize/RemoveParentModulesPlugin.js

@@ -41,7 +41,7 @@ function* getModulesFromMask(mask, ordinalModules) {
 		// Consider the last 32 bits, since that's what Math.clz32 can handle
 		let last32 = Number(BigInt.asUintN(32, mask));
 		while (last32 > 0) {
-			let last = Math.clz32(last32);
+			const last = Math.clz32(last32);
 			// The number of trailing zeros is the number trimmed off the input mask + 31 - the number of leading zeros
 			// The 32 is baked into the initial value of offset
 			const moduleIndex = offset - last;
@@ -148,7 +148,7 @@ class RemoveParentModulesPlugin {
 								availableModulesMask = parentMask;
 								changed = true;
 							} else {
-								let newMask = availableModulesMask & parentMask;
+								const newMask = availableModulesMask & parentMask;
 								if (newMask !== availableModulesMask) {
 									changed = true;
 									availableModulesMask = newMask;
@@ -177,7 +177,7 @@ class RemoveParentModulesPlugin {
 						chunk.groupsIterable,
 						chunkGroup => availableModulesMap.get(chunkGroup)
 					);
-					if (availableModulesSets.some(s => s === undefined)) continue; // No info about this chunk group
+					if (availableModulesSets.includes(undefined)) continue; // No info about this chunk group
 
 					const availableModulesMask = intersectMasks(availableModulesSets);
 					const toRemoveMask = chunkMask & availableModulesMask;

package/lib/optimize/SideEffectsFlagPlugin.js

@@ -23,6 +23,7 @@ const formatLocation = require("../formatLocation");
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
@@ -57,7 +58,7 @@ const globToRegexp = (glob, cache) => {
 	}
 	const baseRegexp = glob2regexp(glob, { globstar: true, extended: true });
 	const regexpSource = baseRegexp.source;
-	const regexp = new RegExp("^(\\./)?" + regexpSource.slice(1));
+	const regexp = new RegExp(`^(\\./)?${regexpSource.slice(1)}`);
 	cache.set(glob, regexp);
 	return regexp;
 };
@@ -71,6 +72,7 @@ class SideEffectsFlagPlugin {
 	constructor(analyseSource = true) {
 		this._analyseSource = analyseSource;
 	}
+
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
@@ -321,7 +323,9 @@ class SideEffectsFlagPlugin {
 															? [...exportName, ...ids.slice(1)]
 															: ids.slice(1)
 													);
-													return moduleGraph.getConnection(dep);
+													return /** @type {ModuleGraphConnection} */ (
+														moduleGraph.getConnection(dep)
+													);
 												}
 											);
 											continue;

package/lib/optimize/SplitChunksPlugin.js

@@ -28,11 +28,10 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 /** @typedef {import("../../declarations/WebpackOptions").Output} OutputOptions */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../ChunkGroup")} ChunkGroup */
-/** @typedef {import("../Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("../Compilation").PathData} PathData */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../TemplatedPathPlugin").TemplatePath} TemplatePath */
 /** @typedef {import("../util/deterministicGrouping").GroupedItems<Module>} DeterministicGroupingGroupedItemsForModule */
 /** @typedef {import("../util/deterministicGrouping").Options<Module>} DeterministicGroupingOptionsForModule */
 
@@ -67,7 +66,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {number=} minChunks
  * @property {number=} maxAsyncRequests
  * @property {number=} maxInitialRequests
- * @property {(string | function(PathData, AssetInfo=): string)=} filename
+ * @property {TemplatePath=} filename
  * @property {string=} idHint
  * @property {string=} automaticNameDelimiter
  * @property {boolean=} reuseExistingChunk
@@ -89,7 +88,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {number=} minChunks
  * @property {number=} maxAsyncRequests
  * @property {number=} maxInitialRequests
- * @property {(string | function(PathData, AssetInfo=): string)=} filename
+ * @property {TemplatePath=} filename
  * @property {string=} idHint
  * @property {string} automaticNameDelimiter
  * @property {boolean} reuseExistingChunk
@@ -144,7 +143,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {number} maxAsyncRequests
  * @property {number} maxInitialRequests
  * @property {boolean} hidePathInfo
- * @property {string | function(PathData, AssetInfo=): string} filename
+ * @property {TemplatePath} filename
  * @property {string} automaticNameDelimiter
  * @property {GetCacheGroups} getCacheGroups
  * @property {GetName} getName
@@ -167,9 +166,8 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 const defaultGetName = /** @type {GetName} */ (() => {});
 
 const deterministicGroupingForModules =
-	/** @type {function(DeterministicGroupingOptionsForModule): DeterministicGroupingGroupedItemsForModule[]} */ (
-		deterministicGrouping
-	);
+	/** @type {function(DeterministicGroupingOptionsForModule): DeterministicGroupingGroupedItemsForModule[]} */
+	(deterministicGrouping);
 
 /** @type {WeakMap<Module, string>} */
 const getKeyCache = new WeakMap();
@@ -180,11 +178,13 @@ const getKeyCache = new WeakMap();
  * @returns {string} hashed filename
  */
 const hashFilename = (name, outputOptions) => {
-	const digest = /** @type {string} */ (
-		createHash(outputOptions.hashFunction)
-			.update(name)
-			.digest(outputOptions.hashDigest)
-	);
+	const digest =
+		/** @type {string} */
+		(
+			createHash(outputOptions.hashFunction)
+				.update(name)
+				.digest(outputOptions.hashDigest)
+		);
 	return digest.slice(0, 8);
 };
 
@@ -200,10 +200,21 @@ const getRequests = chunk => {
 	return requests;
 };
 
+/**
+ * @template {object} T
+ * @template {object} R
+ * @param {T} obj obj an object
+ * @param {function(T[keyof T], keyof T): T[keyof T]} fn fn
+ * @returns {T} result
+ */
 const mapObject = (obj, fn) => {
 	const newObj = Object.create(null);
 	for (const key of Object.keys(obj)) {
-		newObj[key] = fn(obj[key], key);
+		newObj[key] = fn(
+			obj[/** @type {keyof T} */ (key)],
+			/** @type {keyof T} */
+			(key)
+		);
 	}
 	return newObj;
 };
@@ -283,13 +294,12 @@ const normalizeSizes = (value, defaultSizeTypes) => {
 		return o;
 	} else if (typeof value === "object" && value !== null) {
 		return { ...value };
-	} else {
-		return {};
 	}
+	return {};
 };
 
 /**
- * @param {...SplitChunksSizes} sizes the sizes
+ * @param {...(SplitChunksSizes | undefined)} sizes the sizes
  * @returns {SplitChunksSizes} the merged sizes
  */
 const mergeSizes = (...sizes) => {
@@ -324,11 +334,7 @@ const combineSizes = (a, b, combine) => {
 	/** @type {SplitChunksSizes} */
 	const result = {};
 	for (const key of aKeys) {
-		if (bKeys.has(key)) {
-			result[key] = combine(a[key], b[key]);
-		} else {
-			result[key] = a[key];
-		}
+		result[key] = bKeys.has(key) ? combine(a[key], b[key]) : a[key];
 	}
 	for (const key of bKeys) {
 		if (!aKeys.has(key)) {
@@ -425,9 +431,7 @@ const normalizeChunksFilter = chunks => {
 		return ALL_CHUNK_FILTER;
 	}
 	if (chunks instanceof RegExp) {
-		return chunk => {
-			return chunk.name ? chunks.test(chunk.name) : false;
-		};
+		return chunk => (chunk.name ? chunks.test(chunk.name) : false);
 	}
 	if (typeof chunks === "function") {
 		return chunks;
@@ -500,7 +504,7 @@ const normalizeCacheGroups = (cacheGroups, defaultSizeTypes) => {
 		 */
 		const fn = (module, context) => {
 			/** @type {CacheGroupSource[]} */
-			let results = [];
+			const results = [];
 			for (const fn of handlers) {
 				fn(module, context, results);
 			}
@@ -1210,7 +1214,7 @@ module.exports = class SplitChunksPlugin {
 					// Walk through all modules
 					for (const module of compilation.modules) {
 						// Get cache group
-						let cacheGroups = this.options.getCacheGroups(module, context);
+						const cacheGroups = this.options.getCacheGroups(module, context);
 						if (!Array.isArray(cacheGroups) || cacheGroups.length === 0) {
 							continue;
 						}
@@ -1437,7 +1441,7 @@ module.exports = class SplitChunksPlugin {
 											: item.cacheGroup.maxAsyncRequests
 								);
 								if (
-									isFinite(maxRequests) &&
+									Number.isFinite(maxRequests) &&
 									getRequests(chunk) >= maxRequests
 								) {
 									usedChunks.delete(chunk);
@@ -1482,7 +1486,7 @@ module.exports = class SplitChunksPlugin {
 							usedChunks.size === 1
 						) {
 							const [chunk] = usedChunks;
-							let chunkSizes = Object.create(null);
+							const chunkSizes = Object.create(null);
 							for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
 								if (!item.modules.has(module)) {
 									for (const type of module.getSourceTypes()) {
@@ -1522,7 +1526,7 @@ module.exports = class SplitChunksPlugin {
 
 						// Add a note to the chunk
 						newChunk.chunkReason =
-							(newChunk.chunkReason ? newChunk.chunkReason + ", " : "") +
+							(newChunk.chunkReason ? `${newChunk.chunkReason}, ` : "") +
 							(isReusedWithAllModules
 								? "reused as split chunk"
 								: "split chunk");

package/lib/performance/SizeLimitsPlugin.js

@@ -127,8 +127,8 @@ module.exports = class SizeLimitsPlugin {
 
 				if (size > /** @type {number} */ (entrypointSizeLimit)) {
 					entrypointsOverLimit.push({
-						name: name,
-						size: size,
+						name,
+						size,
 						files: entry.getFiles().filter(fileFilter)
 					});
 					isOverSizeLimitSet.add(entry);

package/lib/prefetch/ChunkPrefetchTriggerRuntimeModule.js

@@ -16,7 +16,7 @@ class ChunkPrefetchTriggerRuntimeModule extends RuntimeModule {
 	 * @param {Record<string|number, (string|number)[]>} chunkMap map from chunk to
 	 */
 	constructor(chunkMap) {
-		super(`chunk prefetch trigger`, RuntimeModule.STAGE_TRIGGER);
+		super("chunk prefetch trigger", RuntimeModule.STAGE_TRIGGER);
 		this.chunkMap = chunkMap;
 	}
 

package/lib/prefetch/ChunkPreloadTriggerRuntimeModule.js

@@ -16,7 +16,7 @@ class ChunkPreloadTriggerRuntimeModule extends RuntimeModule {
 	 * @param {Record<string|number, (string|number)[]>} chunkMap map from chunk to chunks
 	 */
 	constructor(chunkMap) {
-		super(`chunk preload trigger`, RuntimeModule.STAGE_TRIGGER);
+		super("chunk preload trigger", RuntimeModule.STAGE_TRIGGER);
 		this.chunkMap = chunkMap;
 	}
 

package/lib/rules/BasicEffectRulePlugin.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
 /** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
 
 class BasicEffectRulePlugin {
@@ -28,7 +29,8 @@ class BasicEffectRulePlugin {
 				if (unhandledProperties.has(this.ruleProperty)) {
 					unhandledProperties.delete(this.ruleProperty);
 
-					const value = rule[this.ruleProperty];
+					const value =
+						rule[/** @type {keyof RuleSetRule} */ (this.ruleProperty)];
 
 					result.effects.push({
 						type: this.effectType,

package/lib/rules/BasicMatcherRulePlugin.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
 /** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
 /** @typedef {import("./RuleSetCompiler").RuleCondition} RuleCondition */
 
@@ -30,7 +31,8 @@ class BasicMatcherRulePlugin {
 			(path, rule, unhandledProperties, result) => {
 				if (unhandledProperties.has(this.ruleProperty)) {
 					unhandledProperties.delete(this.ruleProperty);
-					const value = rule[this.ruleProperty];
+					const value =
+						rule[/** @type {keyof RuleSetRule} */ (this.ruleProperty)];
 					const condition = ruleSetCompiler.compileCondition(
 						`${path}.${this.ruleProperty}`,
 						value

package/lib/rules/ObjectMatcherRulePlugin.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
 /** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
 /** @typedef {import("./RuleSetCompiler").RuleCondition} RuleCondition */
 /** @typedef {import("./RuleSetCompiler").RuleConditionFunction} RuleConditionFunction */
@@ -32,7 +33,9 @@ class ObjectMatcherRulePlugin {
 			(path, rule, unhandledProperties, result) => {
 				if (unhandledProperties.has(ruleProperty)) {
 					unhandledProperties.delete(ruleProperty);
-					const value = rule[ruleProperty];
+					const value =
+						/** @type {Record<string, any>} */
+						(rule[/** @type {keyof RuleSetRule} */ (ruleProperty)]);
 					for (const property of Object.keys(value)) {
 						const nestedDataProperties = property.split(".");
 						const condition = ruleSetCompiler.compileCondition(