webpack 5.99.9 → 5.100.1

package/lib/optimize/MinChunkSizePlugin.js

@@ -13,7 +13,7 @@ const createSchemaValidation = require("../util/create-schema-validation");
 /** @typedef {import("../Compiler")} Compiler */
 
 const validate = createSchemaValidation(
-	require("../../schemas/plugins/optimize/MinChunkSizePlugin.check.js"),
+	require("../../schemas/plugins/optimize/MinChunkSizePlugin.check"),
 	() => require("../../schemas/plugins/optimize/MinChunkSizePlugin.json"),
 	{
 		name: "Min Chunk Size Plugin",
@@ -65,13 +65,15 @@ class MinChunkSizePlugin {
 						if (chunkGraph.getChunkSize(a, equalOptions) < minChunkSize) {
 							smallChunks.push(a);
 							for (const b of visitedChunks) {
-								if (chunkGraph.canChunksBeIntegrated(b, a))
+								if (chunkGraph.canChunksBeIntegrated(b, a)) {
 									combinations.push([b, a]);
+								}
 							}
 						} else {
 							for (const b of smallChunks) {
-								if (chunkGraph.canChunksBeIntegrated(b, a))
+								if (chunkGraph.canChunksBeIntegrated(b, a)) {
 									combinations.push([b, a]);
+								}
 							}
 						}
 						chunkSizesMap.set(a, chunkGraph.getChunkSize(a, options));
@@ -112,4 +114,5 @@ class MinChunkSizePlugin {
 		});
 	}
 }
+
 module.exports = MinChunkSizePlugin;

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -13,11 +13,11 @@ const { STAGE_DEFAULT } = require("../OptimizationStages");
 const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
 const { compareModulesByIdentifier } = require("../util/comparators");
 const {
+	filterRuntime,
 	intersectRuntime,
+	mergeRuntime,
 	mergeRuntimeOwned,
-	filterRuntime,
-	runtimeToString,
-	mergeRuntime
+	runtimeToString
 } = require("../util/runtime");
 const ConcatenatedModule = require("./ConcatenatedModule");
 
@@ -223,6 +223,11 @@ class ModuleConcatenationPlugin {
 							canBeInner = false;
 						}
 
+						if (moduleGraph.isDeferred(module)) {
+							setInnerBailoutReason(module, "Module is deferred");
+							canBeInner = false;
+						}
+
 						if (canBeRoot) relevantModules.push(module);
 						if (canBeInner) possibleInners.add(module);
 					}
@@ -585,25 +590,27 @@ class ModuleConcatenationPlugin {
 		}
 
 		// Module must be in the correct chunks
-		const missingChunks = Array.from(
-			chunkGraph.getModuleChunksIterable(config.rootModule)
-		).filter(chunk => !chunkGraph.isModuleInChunk(module, chunk));
+		const missingChunks = [
+			...chunkGraph.getModuleChunksIterable(config.rootModule)
+		].filter(chunk => !chunkGraph.isModuleInChunk(module, chunk));
 		if (missingChunks.length > 0) {
 			/**
 			 * @param {RequestShortener} requestShortener request shortener
 			 * @returns {string} problem description
 			 */
 			const problem = requestShortener => {
-				const missingChunksList = Array.from(
-					new Set(missingChunks.map(chunk => chunk.name || "unnamed chunk(s)"))
-				).sort();
-				const chunks = Array.from(
-					new Set(
-						Array.from(chunkGraph.getModuleChunksIterable(module)).map(
+				const missingChunksList = [
+					...new Set(
+						missingChunks.map(chunk => chunk.name || "unnamed chunk(s)")
+					)
+				].sort();
+				const chunks = [
+					...new Set(
+						[...chunkGraph.getModuleChunksIterable(module)].map(
 							chunk => chunk.name || "unnamed chunk(s)"
 						)
 					)
-				).sort();
+				].sort();
 				return `Module ${module.readableIdentifier(
 					requestShortener
 				)} is not in the same chunk(s) (expected in chunk(s) ${missingChunksList.join(
@@ -638,7 +645,7 @@ class ModuleConcatenationPlugin {
 					const importingExplanations = new Set(
 						activeNonModulesConnections.map(c => c.explanation).filter(Boolean)
 					);
-					const explanations = Array.from(importingExplanations).sort();
+					const explanations = [...importingExplanations].sort();
 					return `Module ${module.readableIdentifier(
 						requestShortener
 					)} is referenced ${
@@ -672,12 +679,13 @@ class ModuleConcatenationPlugin {
 				const activeConnections = connections.filter(connection =>
 					connection.isActive(runtime)
 				);
-				if (activeConnections.length > 0)
+				if (activeConnections.length > 0) {
 					incomingConnectionsFromModules.set(originModule, activeConnections);
+				}
 			}
 		}
 
-		const incomingModules = Array.from(incomingConnectionsFromModules.keys());
+		const incomingModules = [...incomingConnectionsFromModules.keys()];
 
 		// Module must be in the same chunks like the referencing module
 		const otherChunkModules = incomingModules.filter(originModule => {
@@ -718,8 +726,9 @@ class ModuleConcatenationPlugin {
 					!connection.dependency ||
 					!(connection.dependency instanceof HarmonyImportDependency)
 			);
-			if (selected.length > 0)
+			if (selected.length > 0) {
 				nonHarmonyConnections.set(originModule, connections);
+			}
 		}
 		if (nonHarmonyConnections.size > 0) {
 			/**
@@ -727,18 +736,18 @@ class ModuleConcatenationPlugin {
 			 * @returns {string} problem description
 			 */
 			const problem = requestShortener => {
-				const names = Array.from(nonHarmonyConnections)
+				const names = [...nonHarmonyConnections]
 					.map(
 						([originModule, connections]) =>
 							`${originModule.readableIdentifier(
 								requestShortener
-							)} (referenced with ${Array.from(
-								new Set(
+							)} (referenced with ${[
+								...new Set(
 									connections
 										.map(c => c.dependency && c.dependency.type)
 										.filter(Boolean)
 								)
-							)
+							]
 								.sort()
 								.join(", ")})`
 					)
@@ -898,7 +907,7 @@ class ConcatConfiguration {
 	 */
 	getWarningsSorted() {
 		return new Map(
-			Array.from(this.warnings).sort((a, b) => {
+			[...this.warnings].sort((a, b) => {
 				const ai = a[0].identifier();
 				const bi = b[0].identifier();
 				if (ai < bi) return -1;

package/lib/optimize/RealContentHashPlugin.js

@@ -6,7 +6,7 @@
 "use strict";
 
 const { SyncBailHook } = require("tapable");
-const { RawSource, CachedSource, CompatSource } = require("webpack-sources");
+const { CachedSource, CompatSource, RawSource } = require("webpack-sources");
 const Compilation = require("../Compilation");
 const WebpackError = require("../WebpackError");
 const { compareSelect, compareStrings } = require("../util/comparators");
@@ -214,7 +214,7 @@ class RealContentHashPlugin {
 							}
 							const etag = cacheAnalyse.mergeEtags(
 								cacheAnalyse.getLazyHashedEtag(source),
-								Array.from(hashes).join("|")
+								[...hashes].join("|")
 							);
 							[asset.referencedHashes, asset.ownHashes] =
 								await cacheAnalyse.providePromise(name, etag, () => {
@@ -288,6 +288,7 @@ ${referencingAssets
 							a => a.name
 						)})`;
 					};
+					/** @type {Set<string>} */
 					const hashesInOrder = new Set();
 					for (const hash of hashToAssets.keys()) {
 						/**
@@ -316,6 +317,7 @@ ${referencingAssets
 						if (hashesInOrder.has(hash)) continue;
 						add(hash, new Set());
 					}
+					/** @type {Map<string, string>} */
 					const hashToNewHash = new Map();
 					/**
 					 * @param {AssetInfoForRealContentHash} asset asset info
@@ -338,10 +340,9 @@ ${referencingAssets
 						return (asset.contentComputePromise = (async () => {
 							if (
 								/** @type {OwnHashes} */ (asset.ownHashes).size > 0 ||
-								Array.from(
-									/** @type {ReferencedHashes} */
-									(asset.referencedHashes)
-								).some(hash => hashToNewHash.get(hash) !== hash)
+								[
+									.../** @type {ReferencedHashes} */ (asset.referencedHashes)
+								].some(hash => hashToNewHash.get(hash) !== hash)
 							) {
 								const identifier = asset.name;
 								const etag = getEtag(asset);
@@ -349,8 +350,9 @@ ${referencingAssets
 									identifier,
 									etag,
 									() => {
-										const newContent = asset.content.replace(hashRegExp, hash =>
-											hashToNewHash.get(hash)
+										const newContent = asset.content.replace(
+											hashRegExp,
+											hash => /** @type {string} */ (hashToNewHash.get(hash))
 										);
 										return new RawSource(newContent);
 									}
@@ -363,15 +365,15 @@ ${referencingAssets
 					 * @returns {Promise<void>}
 					 */
 					const computeNewContentWithoutOwn = asset => {
-						if (asset.contentComputeWithoutOwnPromise)
+						if (asset.contentComputeWithoutOwnPromise) {
 							return asset.contentComputeWithoutOwnPromise;
+						}
 						return (asset.contentComputeWithoutOwnPromise = (async () => {
 							if (
 								/** @type {OwnHashes} */ (asset.ownHashes).size > 0 ||
-								Array.from(
-									/** @type {ReferencedHashes} */
-									(asset.referencedHashes)
-								).some(hash => hashToNewHash.get(hash) !== hash)
+								[
+									.../** @type {ReferencedHashes} */ (asset.referencedHashes)
+								].some(hash => hashToNewHash.get(hash) !== hash)
 							) {
 								const identifier = `${asset.name}|without-own`;
 								const etag = getEtag(asset);
@@ -383,11 +385,12 @@ ${referencingAssets
 											hashRegExp,
 											hash => {
 												if (
-													/** @type {OwnHashes} */ (asset.ownHashes).has(hash)
+													/** @type {OwnHashes} */
+													(asset.ownHashes).has(hash)
 												) {
 													return "";
 												}
-												return hashToNewHash.get(hash);
+												return /** @type {string} */ (hashToNewHash.get(hash));
 											}
 										);
 										return new RawSource(newContent);
@@ -436,15 +439,18 @@ ${referencingAssets
 					await Promise.all(
 						assetsWithInfo.map(async asset => {
 							await computeNewContent(asset);
-							const newName = asset.name.replace(hashRegExp, hash =>
-								hashToNewHash.get(hash)
+							const newName = asset.name.replace(
+								hashRegExp,
+								hash => /** @type {string} */ (hashToNewHash.get(hash))
 							);
 
 							const infoUpdate = {};
-							const hash = asset.info.contenthash;
+							const hash = /** @type {string} */ (asset.info.contenthash);
 							infoUpdate.contenthash = Array.isArray(hash)
-								? hash.map(hash => hashToNewHash.get(hash))
-								: hashToNewHash.get(hash);
+								? hash.map(
+										hash => /** @type {string} */ (hashToNewHash.get(hash))
+									)
+								: /** @type {string} */ (hashToNewHash.get(hash));
 
 							if (asset.newSource !== undefined) {
 								compilation.updateAsset(

package/lib/optimize/RemoveEmptyChunksPlugin.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const { STAGE_BASIC, STAGE_ADVANCED } = require("../OptimizationStages");
+const { STAGE_ADVANCED, STAGE_BASIC } = require("../OptimizationStages");
 
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
@@ -56,4 +56,5 @@ class RemoveEmptyChunksPlugin {
 		});
 	}
 }
+
 module.exports = RemoveEmptyChunksPlugin;

package/lib/optimize/RemoveParentModulesPlugin.js

@@ -203,4 +203,5 @@ class RemoveParentModulesPlugin {
 		});
 	}
 }
+
 module.exports = RemoveParentModulesPlugin;

package/lib/optimize/SideEffectsFlagPlugin.js

@@ -8,8 +8,8 @@
 const glob2regexp = require("glob-to-regexp");
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
-	JAVASCRIPT_MODULE_TYPE_ESM,
-	JAVASCRIPT_MODULE_TYPE_DYNAMIC
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+	JAVASCRIPT_MODULE_TYPE_ESM
 } = require("../ModuleTypeConstants");
 const { STAGE_DEFAULT } = require("../OptimizationStages");
 const HarmonyExportImportedSpecifierDependency = require("../dependencies/HarmonyExportImportedSpecifierDependency");
@@ -400,4 +400,5 @@ class SideEffectsFlagPlugin {
 		}
 	}
 }
+
 module.exports = SideEffectsFlagPlugin;

package/lib/optimize/SplitChunksPlugin.js

@@ -12,8 +12,8 @@ const { requestToId } = require("../ids/IdHelpers");
 const { isSubset } = require("../util/SetHelpers");
 const SortableSet = require("../util/SortableSet");
 const {
-	compareModulesByIdentifier,
-	compareIterables
+	compareIterables,
+	compareModulesByIdentifier
 } = require("../util/comparators");
 const createHash = require("../util/createHash");
 const deterministicGrouping = require("../util/deterministicGrouping");
@@ -279,10 +279,10 @@ const INITIAL_CHUNK_FILTER = chunk => chunk.canBeInitial();
  */
 const ASYNC_CHUNK_FILTER = chunk => !chunk.canBeInitial();
 /**
- * @param {Chunk} chunk the chunk
+ * @param {Chunk} _chunk the chunk
  * @returns {boolean} always true
  */
-const ALL_CHUNK_FILTER = chunk => true;
+const ALL_CHUNK_FILTER = _chunk => true;
 
 /**
  * @param {OptimizationSplitChunksSizes | undefined} value the sizes
@@ -853,7 +853,7 @@ module.exports = class SplitChunksPlugin {
 							chunk,
 							index | BigInt((Math.random() * 0x7fffffff) | 0)
 						);
-						index = index << ONE;
+						index <<= ONE;
 					}
 					/**
 					 * @param {Iterable<Chunk>} chunks list of chunks
@@ -871,7 +871,7 @@ module.exports = class SplitChunksPlugin {
 							/** @type {bigint} */ (chunkIndexMap.get(result.value));
 						while (!(result = iterator.next()).done) {
 							const raw = chunkIndexMap.get(result.value);
-							key = key ^ /** @type {bigint} */ (raw);
+							key ^= /** @type {bigint} */ (raw);
 						}
 						return key;
 					};
@@ -931,7 +931,7 @@ module.exports = class SplitChunksPlugin {
 						/** @type {Set<Chunk>} */
 						const singleChunkSets = new Set();
 						for (const module of compilation.modules) {
-							const groupedChunks = Array.from(groupChunksByExports(module));
+							const groupedChunks = [...groupChunksByExports(module)];
 							groupedByExportsMap.set(module, groupedChunks);
 							for (const chunks of groupedChunks) {
 								if (chunks.length === 1) {
@@ -1270,8 +1270,9 @@ module.exports = class SplitChunksPlugin {
 								(groupedByExportsMap.get(module));
 							for (const chunks of groupedByUsedExports) {
 								const chunksKey = getKey(chunks);
-								for (const comb of getExportsCombinations(chunksKey))
+								for (const comb of getExportsCombinations(chunksKey)) {
 									set.add(comb);
+								}
 							}
 							return set;
 						});
@@ -1489,10 +1490,11 @@ module.exports = class SplitChunksPlugin {
 						// Were some (invalid) chunks removed from usedChunks?
 						// => readd all modules to the queue, as things could have been changed
 						if (usedChunks.size < item.chunks.size) {
-							if (isExistingChunk)
+							if (isExistingChunk) {
 								usedChunks.add(/** @type {Chunk} */ (newChunk));
+							}
 							if (usedChunks.size >= item.cacheGroup.minChunks) {
-								const chunksArr = Array.from(usedChunks);
+								const chunksArr = [...usedChunks];
 								for (const module of item.modules) {
 									addModuleToChunksInfoMap(
 										item.cacheGroup,
@@ -1618,7 +1620,7 @@ module.exports = class SplitChunksPlugin {
 									: item.cacheGroup.maxInitialSize,
 								automaticNameDelimiter: item.cacheGroup.automaticNameDelimiter,
 								keys: oldMaxSizeSettings
-									? oldMaxSizeSettings.keys.concat(item.cacheGroup.key)
+									? [...oldMaxSizeSettings.keys, item.cacheGroup.key]
 									: [item.cacheGroup.key]
 							});
 						}
@@ -1672,7 +1674,7 @@ module.exports = class SplitChunksPlugin {
 
 					// Make sure that maxSize is fulfilled
 					const { fallbackCacheGroup } = this.options;
-					for (const chunk of Array.from(compilation.chunks)) {
+					for (const chunk of compilation.chunks) {
 						const chunkConfig = maxSizeQueueMap.get(chunk);
 						const {
 							minSize,
@@ -1680,8 +1682,9 @@ module.exports = class SplitChunksPlugin {
 							maxInitialSize,
 							automaticNameDelimiter
 						} = chunkConfig || fallbackCacheGroup;
-						if (!chunkConfig && !fallbackCacheGroup.chunksFilter(chunk))
+						if (!chunkConfig && !fallbackCacheGroup.chunksFilter(chunk)) {
 							continue;
+						}
 						/** @type {SplitChunksSizes} */
 						let maxSize;
 						if (chunk.isOnlyInitial()) {

package/lib/rules/BasicEffectRulePlugin.js

@@ -16,6 +16,8 @@
 
 /** @typedef {KeysOfTypes<RuleSetRule, string | boolean | { [k: string]: EXPECTED_ANY }>} BasicEffectRuleKeys */
 
+const PLUGIN_NAME = "BasicEffectRulePlugin";
+
 class BasicEffectRulePlugin {
 	/**
 	 * @param {BasicEffectRuleKeys} ruleProperty the rule property
@@ -32,8 +34,8 @@ class BasicEffectRulePlugin {
 	 */
 	apply(ruleSetCompiler) {
 		ruleSetCompiler.hooks.rule.tap(
-			"BasicEffectRulePlugin",
-			(path, rule, unhandledProperties, result, references) => {
+			PLUGIN_NAME,
+			(path, rule, unhandledProperties, result) => {
 				if (unhandledProperties.has(this.ruleProperty)) {
 					unhandledProperties.delete(this.ruleProperty);
 

package/lib/rules/BasicMatcherRulePlugin.js

@@ -20,6 +20,8 @@
 
 /** @typedef {KeysOfTypes<RuleSetRule, RuleSetConditionOrConditions | RuleSetConditionOrConditionsAbsolute>} BasicMatcherRuleKeys */
 
+const PLUGIN_NAME = "BasicMatcherRulePlugin";
+
 class BasicMatcherRulePlugin {
 	/**
 	 * @param {BasicMatcherRuleKeys} ruleProperty the rule property
@@ -38,7 +40,7 @@ class BasicMatcherRulePlugin {
 	 */
 	apply(ruleSetCompiler) {
 		ruleSetCompiler.hooks.rule.tap(
-			"BasicMatcherRulePlugin",
+			PLUGIN_NAME,
 			(path, rule, unhandledProperties, result) => {
 				if (unhandledProperties.has(this.ruleProperty)) {
 					unhandledProperties.delete(this.ruleProperty);

package/lib/rules/ObjectMatcherRulePlugin.js

@@ -20,6 +20,8 @@
 
 /** @typedef {KeysOfTypes<RuleSetRule, { [k: string]: RuleSetConditionOrConditions }>} ObjectMatcherRuleKeys */
 
+const PLUGIN_NAME = "ObjectMatcherRulePlugin";
+
 class ObjectMatcherRulePlugin {
 	/**
 	 * @param {ObjectMatcherRuleKeys} ruleProperty the rule property
@@ -39,7 +41,7 @@ class ObjectMatcherRulePlugin {
 	apply(ruleSetCompiler) {
 		const { ruleProperty, dataProperty } = this;
 		ruleSetCompiler.hooks.rule.tap(
-			"ObjectMatcherRulePlugin",
+			PLUGIN_NAME,
 			(path, rule, unhandledProperties, result) => {
 				if (unhandledProperties.has(ruleProperty)) {
 					unhandledProperties.delete(ruleProperty);

package/lib/rules/RuleSetCompiler.js

@@ -10,6 +10,7 @@ const { SyncHook } = require("tapable");
 /** @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 */
 
@@ -54,12 +55,22 @@ const { SyncHook } = require("tapable");
  * @property {CompiledRule[]=} oneOf
  */
 
+/** @typedef {"use" | "use-pre" | "use-post"} EffectUseType */
+
+/**
+ * @typedef {object} EffectUse
+ * @property {EffectUseType} type
+ * @property {{ loader: string, options?: string | null | Record<string, EXPECTED_ANY>, ident?: string }} value
+ */
+
 /**
- * @typedef {object} Effect
+ * @typedef {object} EffectBasic
  * @property {string} type
- * @property {TODO} value
+ * @property {EXPECTED_ANY} value
  */
 
+/** @typedef {EffectUse | EffectBasic} Effect */
+
 /** @typedef {Map<string, RuleSetLoaderOptions>} References */
 
 /**
@@ -208,6 +219,7 @@ class RuleSetCompiler {
 	 * @returns {CompiledRule} normalized and compiled rule for processing
 	 */
 	compileRule(path, rule, refs) {
+		/** @type {Set<string>} */
 		const unhandledProperties = new Set(
 			Object.keys(rule).filter(
 				key => rule[/** @type {keyof RuleSetRule} */ (key)] !== undefined
@@ -227,16 +239,18 @@ class RuleSetCompiler {
 		if (unhandledProperties.has("rules")) {
 			unhandledProperties.delete("rules");
 			const rules = rule.rules;
-			if (!Array.isArray(rules))
+			if (!Array.isArray(rules)) {
 				throw this.error(path, rules, "Rule.rules must be an array of rules");
+			}
 			compiledRule.rules = this.compileRules(`${path}.rules`, rules, refs);
 		}
 
 		if (unhandledProperties.has("oneOf")) {
 			unhandledProperties.delete("oneOf");
 			const oneOf = rule.oneOf;
-			if (!Array.isArray(oneOf))
+			if (!Array.isArray(oneOf)) {
 				throw this.error(path, oneOf, "Rule.oneOf must be an array of rules");
+			}
 			compiledRule.oneOf = this.compileRules(`${path}.oneOf`, oneOf, refs);
 		}
 
@@ -244,7 +258,7 @@ class RuleSetCompiler {
 			throw this.error(
 				path,
 				rule,
-				`Properties ${Array.from(unhandledProperties).join(", ")} are unknown`
+				`Properties ${[...unhandledProperties].join(", ")} are unknown`
 			);
 		}
 

package/lib/rules/UseEffectRulePlugin.js

@@ -16,6 +16,9 @@ const util = require("util");
 /** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
 /** @typedef {import("./RuleSetCompiler").Effect} Effect */
 /** @typedef {import("./RuleSetCompiler").EffectData} EffectData */
+/** @typedef {import("./RuleSetCompiler").EffectUseType} EffectUseType */
+
+const PLUGIN_NAME = "UseEffectRulePlugin";
 
 class UseEffectRulePlugin {
 	/**
@@ -24,7 +27,7 @@ class UseEffectRulePlugin {
 	 */
 	apply(ruleSetCompiler) {
 		ruleSetCompiler.hooks.rule.tap(
-			"UseEffectRulePlugin",
+			PLUGIN_NAME,
 			(path, rule, unhandledProperties, result, references) => {
 				/**
 				 * @param {keyof RuleSetRule} property property
@@ -50,7 +53,9 @@ class UseEffectRulePlugin {
 					const use = /** @type {RuleSetUse} */ (rule.use);
 					const enforce = rule.enforce;
 
-					const type = enforce ? `use-${enforce}` : "use";
+					const type =
+						/** @type {EffectUseType} */
+						(enforce ? `use-${enforce}` : "use");
 
 					/**
 					 * @param {string} path options path
@@ -87,7 +92,7 @@ class UseEffectRulePlugin {
 								}
 							};
 						}
-						const loader = item.loader;
+						const loader = /** @type {string} */ (item.loader);
 						const options = item.options;
 						let ident = item.ident;
 						if (options && typeof options === "object") {
@@ -205,12 +210,15 @@ class UseEffectRulePlugin {
 
 					const ident =
 						options && typeof options === "object" ? path : undefined;
-					references.set(
-						/** @type {TODO} */
-						(ident),
-						/** @type {RuleSetLoaderOptions} */
-						(options)
-					);
+
+					if (ident) {
+						references.set(
+							ident,
+							/** @type {RuleSetLoaderOptions} */
+							(options)
+						);
+					}
+
 					result.effects.push({
 						type: enforce ? `use-${enforce}` : "use",
 						value: {