webpack 5.100.0 → 5.100.2

package/lib/Compilation.js

@@ -292,7 +292,7 @@ const { isSourceEqual } = require("./util/source");
  * @property {boolean=} development true, when asset is only used for development and doesn't count towards user-facing assets
  * @property {boolean=} hotModuleReplacement true, when asset ships data for updating an existing application (HMR)
  * @property {boolean=} javascriptModule true, when asset is javascript and an ESM
- * @property {Record<string, string | string[]>=} related object of pointers to other assets, keyed by type of relation (only points from parent to child)
+ * @property {Record<string, null | string | string[]>=} related object of pointers to other assets, keyed by type of relation (only points from parent to child)
  */
 
 /** @typedef {KnownAssetInfo & Record<string, EXPECTED_ANY>} AssetInfo */

package/lib/Dependency.js

@@ -85,9 +85,11 @@ const memoize = require("./util/memoize");
 
 const TRANSITIVE = Symbol("transitive");
 
-const getIgnoredModule = memoize(
-	() => new RawModule("/* (ignored) */", "ignored", "(ignored)")
-);
+const getIgnoredModule = memoize(() => {
+	const module = new RawModule("/* (ignored) */", "ignored", "(ignored)");
+	module.factoryMeta = { sideEffectFree: true };
+	return module;
+});
 
 class Dependency {
 	constructor() {

package/lib/IgnorePlugin.js

@@ -80,11 +80,14 @@ class IgnorePlugin {
 					resolveData.dependencies.length > 0 &&
 					resolveData.dependencies[0] instanceof EntryDependency
 				) {
-					resolveData.ignoredModule = new RawModule(
+					const module = new RawModule(
 						"",
 						"ignored-entry-module",
 						"(ignored-entry-module)"
 					);
+					module.factoryMeta = { sideEffectFree: true };
+
+					resolveData.ignoredModule = module;
 				}
 
 				return result;

package/lib/ModuleGraph.js

@@ -10,6 +10,7 @@ const ExportsInfo = require("./ExportsInfo");
 const ModuleGraphConnection = require("./ModuleGraphConnection");
 const SortableSet = require("./util/SortableSet");
 const WeakTupleMap = require("./util/WeakTupleMap");
+const { sortWithSourceOrder } = require("./util/comparators");
 
 /** @typedef {import("./Compilation").ModuleMemCaches} ModuleMemCaches */
 /** @typedef {import("./DependenciesBlock")} DependenciesBlock */
@@ -19,6 +20,9 @@ const WeakTupleMap = require("./util/WeakTupleMap");
 /** @typedef {import("./ModuleProfile")} ModuleProfile */
 /** @typedef {import("./RequestShortener")} RequestShortener */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./dependencies/HarmonyImportSideEffectDependency")} HarmonyImportSideEffectDependency */
+/** @typedef {import("./dependencies/HarmonyImportSpecifierDependency")} HarmonyImportSpecifierDependency */
+/** @typedef {import("./util/comparators").DependencySourceOrder} DependencySourceOrder */
 
 /**
  * @callback OptimizationBailoutFunction
@@ -158,6 +162,12 @@ class ModuleGraph {
 		 * @private
 		 */
 		this._cacheStage = undefined;
+
+		/**
+		 * @type {WeakMap<Dependency, DependencySourceOrder>}
+		 * @private
+		 */
+		this._dependencySourceOrderMap = new WeakMap();
 	}
 
 	/**
@@ -186,6 +196,15 @@ class ModuleGraph {
 		dependency._parentModule = module;
 	}
 
+	/**
+	 * @param {Dependency} dependency the dependency
+	 * @param {number} index the index
+	 * @returns {void}
+	 */
+	setParentDependenciesBlockIndex(dependency, index) {
+		dependency._parentDependenciesBlockIndex = index;
+	}
+
 	/**
 	 * @param {Dependency} dependency the dependency
 	 * @returns {Module | undefined} parent module
@@ -265,6 +284,64 @@ class ModuleGraph {
 		targetMgm.incomingConnections.add(newConnection);
 	}
 
+	/**
+	 * @param {Dependency} dependency the need update dependency
+	 * @param {ModuleGraphConnection=} connection the target connection
+	 * @param {Module=} parentModule the parent module
+	 * @returns {void}
+	 */
+	updateParent(dependency, connection, parentModule) {
+		if (this._dependencySourceOrderMap.has(dependency)) {
+			return;
+		}
+		if (!connection || !parentModule) {
+			return;
+		}
+		const originDependency = connection.dependency;
+
+		// src/index.js
+		// import { c } from "lib/c" -> c = 0
+		// import { a, b } from "lib" -> a and b have the same source order -> a = b = 1
+		// import { d } from "lib/d" -> d = 2
+		const currentSourceOrder =
+			/** @type { HarmonyImportSideEffectDependency | HarmonyImportSpecifierDependency} */ (
+				dependency
+			).sourceOrder;
+
+		// lib/index.js (reexport)
+		// import { a } from "lib/a" -> a = 0
+		// import { b } from "lib/b" -> b = 1
+		const originSourceOrder =
+			/** @type { HarmonyImportSideEffectDependency | HarmonyImportSpecifierDependency} */ (
+				originDependency
+			).sourceOrder;
+		if (
+			typeof currentSourceOrder === "number" &&
+			typeof originSourceOrder === "number"
+		) {
+			// src/index.js
+			// import { c } from "lib/c" -> c = 0
+			// import { a } from "lib/a" -> a = 1.0 = 1(main) + 0.0(sub)
+			// import { b } from "lib/b" -> b = 1.1 = 1(main) + 0.1(sub)
+			// import { d } from "lib/d" -> d = 2
+			this._dependencySourceOrderMap.set(dependency, {
+				main: currentSourceOrder,
+				sub: originSourceOrder
+			});
+
+			// If dependencies like HarmonyImportSideEffectDependency and HarmonyImportSpecifierDependency have a SourceOrder,
+			// we sort based on it; otherwise, we preserve the original order.
+			sortWithSourceOrder(
+				parentModule.dependencies,
+				this._dependencySourceOrderMap
+			);
+
+			for (const [index, dep] of parentModule.dependencies.entries()) {
+				this.setParentDependenciesBlockIndex(dep, index);
+			}
+		}
+	}
+
 	/**
 	 * @param {Dependency} dependency the referencing dependency
 	 * @returns {void}

package/lib/NormalModule.js

@@ -40,7 +40,8 @@ const {
 	compareLocations,
 	compareSelect,
 	concatComparators,
-	keepOriginalOrder
+	keepOriginalOrder,
+	sortWithSourceOrder
 } = require("./util/comparators");
 const createHash = require("./util/createHash");
 const { createFakeHook } = require("./util/deprecation");
@@ -99,6 +100,8 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 /** @typedef {import("../declarations/WebpackOptions").HashFunction} HashFunction */
 /** @typedef {import("./util/identifier").AssociatedObjectForCache} AssociatedObjectForCache */
+/** @typedef {import("./dependencies/HarmonyImportSideEffectDependency")} HarmonyImportSideEffectDependency */
+/** @typedef {import("./dependencies/HarmonyImportSpecifierDependency")} HarmonyImportSpecifierDependency */
 /**
  * @template T
  * @typedef {import("./util/deprecation").FakeHook<T>} FakeHook
@@ -1221,6 +1224,7 @@ class NormalModule extends Module {
 						keepOriginalOrder(this.dependencies)
 					)
 				);
+				sortWithSourceOrder(this.dependencies, new WeakMap());
 				this._initBuildHash(compilation);
 				this._lastSuccessfulBuildMeta =
 					/** @type {BuildMeta} */

package/lib/NormalModuleFactory.js

@@ -572,8 +572,11 @@ class NormalModuleFactory extends ModuleFactory {
 
 					/** @type {ModuleSettings} */
 					const settings = {};
+					/** @type {LoaderItem[]} */
 					const useLoadersPost = [];
+					/** @type {LoaderItem[]} */
 					const useLoaders = [];
+					/** @type {LoaderItem[]} */
 					const useLoadersPre = [];
 
 					// handle .webpack[] suffix
@@ -632,7 +635,8 @@ class NormalModuleFactory extends ModuleFactory {
 								typeof r.value === "object" &&
 								r.value !== null &&
 								typeof settings[
-									/** @type {keyof ModuleSettings} */ (r.type)
+									/** @type {keyof ModuleSettings} */
+									(r.type)
 								] === "object" &&
 								settings[/** @type {keyof ModuleSettings} */ (r.type)] !== null
 							) {

package/lib/RawModule.js

@@ -24,6 +24,8 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {import("./Module").NeedBuildCallback} NeedBuildCallback */
 /** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
 /** @typedef {import("./Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
+/** @typedef {import("./ModuleGraph")} ModuleGraph */
+/** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @typedef {import("./RequestShortener")} RequestShortener */
 /** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
@@ -105,6 +107,18 @@ class RawModule extends Module {
 		callback();
 	}
 
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConnectionState} how this module should be connected to referencing modules when consumed for side-effects only
+	 */
+	getSideEffectsConnectionState(moduleGraph) {
+		if (this.factoryMeta !== undefined) {
+			if (this.factoryMeta.sideEffectFree) return false;
+			if (this.factoryMeta.sideEffectFree === false) return true;
+		}
+		return true;
+	}
+
 	/**
 	 * @param {CodeGenerationContext} context context for code generation
 	 * @returns {CodeGenerationResult} result

package/lib/RuntimeTemplate.js

@@ -8,6 +8,9 @@
 const InitFragment = require("./InitFragment");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const Template = require("./Template");
+const {
+	getOutgoingAsyncModules
+} = require("./async-modules/AsyncModuleHelpers");
 const {
 	getMakeDeferredNamespaceModeFromExportsType,
 	getOptimizedDeferredModule
@@ -814,27 +817,12 @@ class RuntimeTemplate {
 			];
 		}
 
-		/** @type {Set<Module>} */
-		const innerAsyncDependencies = new Set();
 		defer = defer && (module.buildMeta ? !module.buildMeta.async : true);
 
-		if (this.compilation.options.experiments.deferImport && defer) {
-			const seen = new Set();
-			(function gatherInnerAsyncDependencies(mod) {
-				if (!moduleGraph.isAsync(mod) || seen.has(mod)) return;
-				seen.add(mod);
-				if (mod.buildMeta && mod.buildMeta.async) {
-					innerAsyncDependencies.add(mod);
-				} else {
-					for (const dep of mod.dependencies) {
-						const module = moduleGraph.getModule(dep);
-						if (module) {
-							gatherInnerAsyncDependencies(module);
-						}
-					}
-				}
-			})(module);
-		}
+		/** @type {Set<Module>} */
+		const outgoingAsyncModules = defer
+			? getOutgoingAsyncModules(moduleGraph, module)
+			: new Set();
 
 		if (chunkGraph.getModuleId(module) === null) {
 			if (weak) {
@@ -877,13 +865,14 @@ class RuntimeTemplate {
 				this,
 				exportsType,
 				moduleId,
-				Array.from(innerAsyncDependencies, mod => chunkGraph.getModuleId(mod))
+				Array.from(outgoingAsyncModules, mod => chunkGraph.getModuleId(mod))
 			)};\n`;
-		} else {
-			importContent = `/* harmony import */ ${optDeclaration}${importVar} = ${RuntimeGlobals.require}(${moduleId});\n`;
+
+			return [importContent, ""];
 		}
+		importContent = `/* harmony import */ ${optDeclaration}${importVar} = ${RuntimeGlobals.require}(${moduleId});\n`;
 
-		if (exportsType === "dynamic" && !defer) {
+		if (exportsType === "dynamic") {
 			runtimeRequirements.add(RuntimeGlobals.compatGetDefaultExport);
 			return [
 				importContent,

package/lib/WebpackOptionsApply.js

@@ -438,6 +438,13 @@ class WebpackOptionsApply extends OptionsApply {
 			new HttpUriPlugin(httpOptions).apply(compiler);
 		}
 
+		if (options.experiments.deferImport) {
+			const JavascriptParser = require("./javascript/JavascriptParser");
+			const importPhases = require("acorn-import-phases");
+
+			JavascriptParser.extend(importPhases({ source: false }));
+		}
+
 		new EntryOptionPlugin().apply(compiler);
 		compiler.hooks.entryOption.call(
 			/** @type {string} */

package/lib/asset/AssetGenerator.js

@@ -57,8 +57,8 @@ const nonNumericOnlyHash = require("../util/nonNumericOnlyHash");
 /**
  * @template T
  * @template U
- * @param {string | Array<T> | Set<T> | undefined} a a
- * @param {string | Array<U> | Set<U> | undefined} b b
+ * @param {null | string | Array<T> | Set<T> | undefined} a a
+ * @param {null | string | Array<U> | Set<U> | undefined} b b
  * @returns {Array<T> & Array<U>} array
  */
 const mergeMaybeArrays = (a, b) => {

package/lib/async-modules/AsyncModuleHelpers.js

@@ -0,0 +1,50 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Haijie Xie @hai-x
+*/
+
+"use strict";
+
+const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
+
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../Module")} Module */
+
+/**
+ * @param {ModuleGraph} moduleGraph module graph
+ * @param {Module} module module
+ * @returns {Set<Module>} set of modules
+ */
+const getOutgoingAsyncModules = (moduleGraph, module) => {
+	/** @type {Set<Module>} */
+	const set = new Set();
+	/** @type {Set<Module>} */
+	const seen = new Set();
+	(function g(/** @type {Module} */ module) {
+		if (!moduleGraph.isAsync(module) || seen.has(module)) return;
+		seen.add(module);
+		if (module.buildMeta && module.buildMeta.async) {
+			set.add(module);
+		} else {
+			const outgoingConnectionMap =
+				moduleGraph.getOutgoingConnectionsByModule(module);
+			if (outgoingConnectionMap) {
+				for (const [module, connections] of outgoingConnectionMap) {
+					if (
+						connections.some(
+							c =>
+								c.dependency instanceof HarmonyImportDependency &&
+								c.isTargetActive(undefined)
+						) &&
+						module
+					) {
+						g(module);
+					}
+				}
+			}
+		}
+	})(module);
+	return set;
+};
+
+module.exports.getOutgoingAsyncModules = getOutgoingAsyncModules;

package/lib/dependencies/HarmonyExportDependencyParserPlugin.js

@@ -77,12 +77,7 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 			clearDep.loc = /** @type {DependencyLocation} */ (statement.loc);
 			clearDep.loc.index = -1;
 			parser.state.module.addPresentationalDependency(clearDep);
-			const { defer } = getImportMode(
-				parser,
-				statement,
-				this.deferImport,
-				true
-			);
+			const { defer } = getImportMode(parser, statement);
 			if (defer) {
 				const error = new WebpackError(
 					"Deferred re-export (`export defer * as namespace from '...'`) is not a part of the Import Defer proposal.\nUse the following code instead:\n    import defer * as namespace from '...';\n    export { namespace };"
@@ -207,12 +202,7 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 						parser.state.harmonyStarExports || new HarmonyStarExportsList();
 				}
 				const attributes = getImportAttributes(statement);
-				const { defer } = getImportMode(
-					parser,
-					statement,
-					this.deferImport,
-					false
-				);
+				const { defer } = getImportMode(parser, statement);
 				const dep = new HarmonyExportImportedSpecifierDependency(
 					/** @type {string} */
 					(source),

package/lib/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -7,7 +7,6 @@
 
 const CommentCompilationWarning = require("../CommentCompilationWarning");
 const HotModuleReplacementPlugin = require("../HotModuleReplacementPlugin");
-const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
 const WebpackError = require("../WebpackError");
 const { getImportAttributes } = require("../javascript/JavascriptParser");
 const InnerGraph = require("../optimize/InnerGraph");
@@ -125,12 +124,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 			parser.state.module.addPresentationalDependency(clearDep);
 			parser.unsetAsiPosition(/** @type {Range} */ (statement.range)[1]);
 			const attributes = getImportAttributes(statement);
-			const { defer } = getImportMode(
-				parser,
-				statement,
-				this.deferImport,
-				true
-			);
+			const { defer } = getImportMode(parser, statement);
 			if (
 				defer &&
 				(statement.specifiers.length !== 1 ||
@@ -156,12 +150,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 			PLUGIN_NAME,
 			(statement, source, id, name) => {
 				const ids = id === null ? [] : [id];
-				const { defer } = getImportMode(
-					parser,
-					statement,
-					this.deferImport,
-					false
-				);
+				const { defer } = getImportMode(parser, statement);
 				parser.tagVariable(name, harmonySpecifierTag, {
 					name,
 					source,
@@ -398,23 +387,10 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 /**
  * @param {JavascriptParser} parser parser
  * @param {ExportNamedDeclaration | ExportAllDeclaration | ImportDeclaration} node node
- * @param {boolean | undefined} deferImportEnabled defer import enabled
- * @param {boolean} reportSyntaxError report syntax error
  * @returns {{defer: boolean}} import attributes
  */
-function getImportMode(parser, node, deferImportEnabled, reportSyntaxError) {
-	const result = { defer: false };
-	if ("phase" in node && node.phase === "defer") {
-		if (deferImportEnabled) {
-			result.defer = true;
-		} else if (reportSyntaxError) {
-			const error = new WebpackError(
-				"Deferred import syntax (`import defer * as namespace from '...'`) cannot be used unless experimental.deferImport is true."
-			);
-			error.loc = node.loc || undefined;
-			parser.state.current.addError(error);
-		}
-	}
+function getImportMode(parser, node) {
+	const result = { defer: "phase" in node && node.phase === "defer" };
 	if (!node.range) {
 		return result;
 	}
@@ -437,7 +413,7 @@ function getImportMode(parser, node, deferImportEnabled, reportSyntaxError) {
 			result.defer = options.webpackDefer;
 		} else if (node.loc) {
 			parser.state.module.addWarning(
-				new UnsupportedFeatureWarning(
+				new CommentCompilationWarning(
 					"webpackDefer magic comment expected a boolean value.",
 					node.loc
 				)

package/lib/dependencies/ModuleDependency.js

@@ -61,11 +61,13 @@ class ModuleDependency extends Dependency {
 	 * @returns {Module} ignored module
 	 */
 	createIgnoredModule(context) {
-		return new RawModule(
+		const module = new RawModule(
 			"/* (ignored) */",
 			`ignored|${context}|${this.request}`,
 			`${this.request} (ignored)`
 		);
+		module.factoryMeta = { sideEffectFree: true };
+		return module;
 	}
 
 	/**

package/lib/javascript/JavascriptParser.js

@@ -7,7 +7,6 @@
 
 const vm = require("vm");
 const { Parser: AcornParser, tokTypes } = require("acorn");
-const acornImportPhases = require("acorn-import-phases");
 const { HookMap, SyncBailHook } = require("tapable");
 const Parser = require("../Parser");
 const StackedMap = require("../util/StackedMap");
@@ -182,10 +181,7 @@ const importAssertions = Parser =>
 	};
 
 // Syntax: https://developer.mozilla.org/en/SpiderMonkey/Parser_API
-const parser = AcornParser.extend(
-	importAssertions,
-	acornImportPhases({ source: false })
-);
+let parser = AcornParser.extend(importAssertions);
 
 /** @typedef {Record<string, string> & { _isLegacyAssert?: boolean }} ImportAttributes */
 
@@ -5135,6 +5131,15 @@ class JavascriptParser extends Parser {
 
 		return /** @type {Program} */ (ast);
 	}
+
+	/**
+	 * @param {((BaseParser: typeof AcornParser) => typeof AcornParser)[]} plugins parser plugin
+	 * @returns {typeof JavascriptParser} parser
+	 */
+	static extend(...plugins) {
+		parser = parser.extend(...plugins);
+		return JavascriptParser;
+	}
 }
 
 module.exports = JavascriptParser;

package/lib/optimize/SideEffectsFlagPlugin.js

@@ -320,8 +320,17 @@ class SideEffectsFlagPlugin {
 												({ module }) =>
 													module.getSideEffectsConnectionState(moduleGraph) ===
 													false,
-												({ module: newModule, export: exportName }) => {
+												({
+													module: newModule,
+													export: exportName,
+													connection: targetConnection
+												}) => {
 													moduleGraph.updateModule(dep, newModule);
+													moduleGraph.updateParent(
+														dep,
+														targetConnection,
+														/** @type {Module} */ (connection.originModule)
+													);
 													moduleGraph.addExplanation(
 														dep,
 														"(skipped side-effect-free modules)"
@@ -353,6 +362,13 @@ class SideEffectsFlagPlugin {
 											if (!target) continue;
 
 											moduleGraph.updateModule(dep, target.module);
+											moduleGraph.updateParent(
+												dep,
+												/** @type {ModuleGraphConnection} */ (
+													target.connection
+												),
+												/** @type {Module} */ (connection.originModule)
+											);
 											moduleGraph.addExplanation(
 												dep,
 												"(skipped side-effect-free modules)"

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} Effect
+ * @typedef {object} EffectUse
+ * @property {EffectUseType} type
+ * @property {{ loader: string, options?: string | null | Record<string, EXPECTED_ANY>, ident?: string }} value
+ */
+
+/**
+ * @typedef {object} EffectBasic
  * @property {string} type
- * @property {TODO} value
+ * @property {EXPECTED_ANY} value
  */
 
+/** @typedef {EffectUse | EffectBasic} Effect */
+
 /** @typedef {Map<string, RuleSetLoaderOptions>} References */
 
 /**

package/lib/rules/UseEffectRulePlugin.js

@@ -16,6 +16,7 @@ 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";
 
@@ -52,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
@@ -89,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") {
@@ -207,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: {

package/lib/stats/DefaultStatsFactoryPlugin.js

@@ -796,6 +796,7 @@ const SIMPLE_EXTRACTORS = {
 						? relatedEntry
 						: [relatedEntry];
 					for (const dep of deps) {
+						if (!dep) continue;
 						const depItem = assetMap.get(dep);
 						if (!depItem) continue;
 						assets.delete(depItem);