@depup/webpack 5.109.0-depup.0 → 5.110.1-depup.0

package/lib/prefetch/StartupAssetHintRuntimeModule.js

@@ -7,16 +7,8 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
-const CssUrlDependency = require("../dependencies/CssUrlDependency");
-const HtmlSourceDependency = require("../dependencies/HtmlSourceDependency");
-const URLDependency = require("../dependencies/URLDependency");
-const ResourceHintRuntimeModule = require("./ResourceHintRuntimeModule");
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @import Compilation from "../Compilation" */
 
 /**
  * Fires `<link rel="prefetch">` / `<link rel="preload">` for every asset
@@ -25,10 +17,17 @@ const ResourceHintRuntimeModule = require("./ResourceHintRuntimeModule");
  * user module evaluates, so by the time user code reaches the
  * corresponding `new URL(...)` (or hands the URL to `<img>`, `fetch`,
  * `new Worker`, etc.), the browser already has the response in flight.
+ *
+ * The calls themselves are rendered by `ResourceHintPlugin`, while runtime
+ * requirements are still open — see `collectStartupAssetHintLines`.
  */
 class StartupAssetHintRuntimeModule extends RuntimeModule {
-	constructor() {
+	/**
+	 * @param {string[]} lines the `<link>` calls this chunk fires at startup
+	 */
+	constructor(lines) {
 		super("startup asset hints", RuntimeModule.STAGE_TRIGGER);
+		this._lines = lines;
 	}
 
 	/**
@@ -37,129 +36,7 @@ class StartupAssetHintRuntimeModule extends RuntimeModule {
 	 */
 	generate() {
 		const compilation = /** @type {Compilation} */ (this.compilation);
-		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
-		const moduleGraph = /** @type {ModuleGraph} */ (compilation.moduleGraph);
-		const runtimeTemplate = compilation.runtimeTemplate;
-		const chunk = /** @type {Chunk} */ (this.chunk);
-		const runtimeRequirements =
-			/** @type {Set<string>} */
-			(chunkGraph.getTreeRuntimeRequirements(chunk));
-
-		// Dedupe per asset module: if the same asset is referenced twice
-		// (e.g. CSS rule says `prefetch`, a JS magic comment says
-		// `preload`), pick `preload` over `prefetch` and keep the most
-		// recently seen explicit attribute overrides. Avoids emitting a
-		// duplicate `<link>` and ordering-dependent winners.
-		/**
-		 * @typedef {object} AssetHintEntry
-		 * @property {import("../Module")} assetModule
-		 * @property {string} request
-		 * @property {boolean} preload
-		 * @property {("low" | "high" | "auto" | undefined)} fetchPriority
-		 * @property {(string | undefined)} as
-		 * @property {(string | undefined)} type
-		 * @property {(string | undefined)} media
-		 */
-		// Per-asset dedupe vs the HTML-head emission by `HtmlEntryDependency`:
-		// if the asset is reachable from an HTML entrypoint's chunks, its
-		// `<link>` lands in that HTML `<head>` already — skip the runtime
-		// hint for that asset so the DOM doesn't carry two tags for one URL.
-		// Set is computed once per compilation from the module graph (stable
-		// across cache reads), never from a mutable cross-module marker.
-		const ResourceHintPlugin = require("./ResourceHintPlugin");
-
-		// `output.resourceHints: "none"` is a hard off switch — the plugin's
-		// runtime-requirements hook already skips adding this module then, so no
-		// `"none"` guard is needed here.
-		const { isHtmlHinted } =
-			ResourceHintPlugin.getCompilationResolver(compilation);
-
-		/** @type {Map<string, AssetHintEntry>} */
-		const perAsset = new Map();
-		for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
-			const deps =
-				/** @type {{ dependencies?: import("../Dependency")[] }} */
-				(module).dependencies;
-			if (!deps) continue;
-			for (const dep of deps) {
-				if (
-					!(dep instanceof URLDependency) &&
-					!(dep instanceof CssUrlDependency) &&
-					!(dep instanceof HtmlSourceDependency)
-				) {
-					continue;
-				}
-				if (!dep.prefetch && !dep.preload) continue;
-				const assetModule = moduleGraph.getModule(dep);
-				if (!assetModule) continue;
-				if (isHtmlHinted(assetModule)) continue;
-				const key = assetModule.identifier();
-				const urlDep =
-					/** @type {URLDependency & Partial<CssUrlDependency> & Partial<HtmlSourceDependency>} */
-					(dep);
-				const existing = perAsset.get(key);
-				if (existing) {
-					if (dep.preload) existing.preload = true;
-					if (dep.fetchPriority) existing.fetchPriority = dep.fetchPriority;
-					if (urlDep.asAttribute) existing.as = urlDep.asAttribute;
-					if (urlDep.typeAttribute) existing.type = urlDep.typeAttribute;
-					if (urlDep.mediaAttribute) existing.media = urlDep.mediaAttribute;
-				} else {
-					perAsset.set(key, {
-						assetModule: /** @type {Module} */ (assetModule),
-						request: dep.request,
-						preload: Boolean(dep.preload),
-						fetchPriority: dep.fetchPriority,
-						as: urlDep.asAttribute,
-						type: urlDep.typeAttribute,
-						media: urlDep.mediaAttribute
-					});
-				}
-			}
-		}
-		const lines = [];
-		for (const entry of perAsset.values()) {
-			const fn = entry.preload
-				? RuntimeGlobals.preloadAsset
-				: RuntimeGlobals.prefetchAsset;
-			// For CSS-only assets (referenced from `url(...)` but never
-			// from JS) the module produces no JS source, so
-			// `__webpack_require__(id)` would throw at runtime. Use the
-			// emitted filename + publicPath directly in that case; asset
-			// modules referenced from JS stay on the existing `moduleRaw`
-			// path which yields the same URL.
-			const hasJsSourceType = entry.assetModule
-				.getSourceTypes()
-				.has("javascript");
-			let hrefExpr;
-			if (hasJsSourceType) {
-				hrefExpr = runtimeTemplate.moduleRaw({
-					chunkGraph,
-					module: entry.assetModule,
-					request: entry.request,
-					runtimeRequirements,
-					weak: false
-				});
-			} else {
-				const buildInfo =
-					/** @type {{ filename?: string }} */
-					(entry.assetModule.buildInfo);
-				if (!buildInfo || !buildInfo.filename) continue;
-				runtimeRequirements.add(RuntimeGlobals.publicPath);
-				hrefExpr = `${RuntimeGlobals.publicPath} + ${JSON.stringify(buildInfo.filename)}`;
-			}
-			const as =
-				entry.as || ResourceHintRuntimeModule.guessAsAttribute(entry.request);
-			lines.push(
-				`${fn}(${hrefExpr}, ${JSON.stringify(as)}, ${
-					entry.type ? JSON.stringify(entry.type) : "undefined"
-				}, ${entry.media ? JSON.stringify(entry.media) : "undefined"}, ${
-					entry.fetchPriority
-						? JSON.stringify(entry.fetchPriority)
-						: "undefined"
-				});`
-			);
-		}
+		const lines = this._lines;
 		if (lines.length === 0) return null;
 		// `__webpack_nonce__` set inside the entry module is too late — the
 		// entry hasn't run yet. Read the nonce off the `<script>` tag that

package/lib/prefetch/parseResourceHintOptions.js

@@ -4,10 +4,14 @@
 
 "use strict";
 
-const UnsupportedFeatureWarning = require("../errors/UnsupportedFeatureWarning");
+const memoize = require("../util/memoize");
 
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("../NormalModule")} NormalModule */
+const getUnsupportedFeatureWarning = memoize(() =>
+	require("../errors/UnsupportedFeatureWarning")
+);
+
+/** @import { DependencyLocation } from "../Dependency" */
+/** @import NormalModule from "../NormalModule" */
 
 /**
  * @typedef {object} ResourceHintOptions
@@ -38,7 +42,7 @@ const parseResourceHintOptions = (importOptions, module, loc) => {
 	 * @returns {void}
 	 */
 	const warn = (message) => {
-		module.addWarning(new UnsupportedFeatureWarning(message, loc));
+		module.addWarning(new (getUnsupportedFeatureWarning())(message, loc));
 	};
 
 	if (importOptions.webpackPrefetch !== undefined) {
@@ -100,4 +104,27 @@ const parseResourceHintOptions = (importOptions, module, loc) => {
 	return hints;
 };
 
+/**
+ * Maps a request/filename to the value of the `<link>` `as` attribute. Best
+ * effort — falls back to `"fetch"` when the type cannot be guessed. Pattern
+ * matches against the path part, ignoring any query string suffix.
+ * @param {string} request request/filename
+ * @returns {string} value for the `as` attribute
+ */
+const guessAsAttribute = (request) => {
+	if (/\.(png|jpe?g|gif|svg|webp|avif|bmp|ico|tiff?)(\?.*)?$/i.test(request)) {
+		return "image";
+	}
+	if (/\.(woff2?|ttf|otf|eot)(\?.*)?$/i.test(request)) return "font";
+	if (/\.css(\?.*)?$/i.test(request)) return "style";
+	if (/\.[cm]?jsx?(\?.*)?$/i.test(request)) return "script";
+	if (/\.[cm]?tsx?(\?.*)?$/i.test(request)) return "script";
+	if (/\.(mp3|wav|flac|aac|m4a|ogg|oga)(\?.*)?$/i.test(request)) return "audio";
+	if (/\.(mp4|webm|mkv|mov|m4v|ogv|avi)(\?.*)?$/i.test(request)) return "video";
+	if (/\.vtt(\?.*)?$/i.test(request)) return "track";
+	return "fetch";
+};
+
+parseResourceHintOptions.guessAsAttribute = guessAsAttribute;
+
 module.exports = parseResourceHintOptions;

package/lib/rules/BasicEffectRulePlugin.js

@@ -5,8 +5,8 @@
 
 "use strict";
 
-/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
-/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
+/** @import { RuleSetRule } from "../../declarations/WebpackOptions" */
+/** @import RuleSetCompiler from "./RuleSetCompiler" */
 
 /**
  * Defines the keys of types type used by this module.

package/lib/rules/BasicMatcherRulePlugin.js

@@ -5,10 +5,14 @@
 
 "use strict";
 
-/** @typedef {import("../../declarations/WebpackOptions").RuleSetConditionOrConditions} RuleSetConditionOrConditions */
-/** @typedef {import("../../declarations/WebpackOptions").RuleSetConditionOrConditionsAbsolute} RuleSetConditionOrConditionsAbsolute */
-/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
-/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
+/**
+ * @import {
+ * 	RuleSetConditionOrConditions,
+ * 	RuleSetConditionOrConditionsAbsolute,
+ * 	RuleSetRule
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import RuleSetCompiler from "./RuleSetCompiler" */
 
 /**
  * Defines the keys of types type used by this module.

package/lib/rules/GlobMatcherRulePlugin.js

@@ -0,0 +1,68 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+/**
+ * @import {
+ * 	RuleSetGlob,
+ * 	RuleSetGlobs,
+ * 	RuleSetRule
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import RuleSetCompiler from "./RuleSetCompiler" */
+
+/**
+ * Defines the keys of types type used by this module.
+ * @template T
+ * @template {T[keyof T]} V
+ * @typedef {import("./RuleSetCompiler").KeysOfTypes<T, V>} KeysOfTypes
+ */
+
+/** @typedef {KeysOfTypes<RuleSetRule, RuleSetGlob | RuleSetGlobs>} GlobMatcherRuleKeys */
+
+const PLUGIN_NAME = "GlobMatcherRulePlugin";
+
+class GlobMatcherRulePlugin {
+	/**
+	 * Creates an instance of GlobMatcherRulePlugin.
+	 * @param {GlobMatcherRuleKeys} ruleProperty the rule property
+	 * @param {string=} dataProperty the data property
+	 */
+	constructor(ruleProperty, dataProperty) {
+		/** @type {GlobMatcherRuleKeys} */
+		this.ruleProperty = ruleProperty;
+		/** @type {string | GlobMatcherRuleKeys} */
+		this.dataProperty = dataProperty || ruleProperty;
+	}
+
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @param {RuleSetCompiler} ruleSetCompiler the rule set compiler
+	 * @returns {void}
+	 */
+	apply(ruleSetCompiler) {
+		ruleSetCompiler.hooks.rule.tap(
+			PLUGIN_NAME,
+			(path, rule, unhandledProperties, result) => {
+				if (unhandledProperties.has(this.ruleProperty)) {
+					unhandledProperties.delete(this.ruleProperty);
+					const condition = ruleSetCompiler.compileGlobCondition(
+						`${path}.${this.ruleProperty}`,
+						/** @type {RuleSetGlob | RuleSetGlobs} */
+						(rule[this.ruleProperty])
+					);
+					result.conditions.push({
+						property: this.dataProperty,
+						matchWhenEmpty: condition.matchWhenEmpty,
+						fn: condition.fn
+					});
+				}
+			}
+		);
+	}
+}
+
+module.exports = GlobMatcherRulePlugin;

package/lib/rules/ObjectMatcherRulePlugin.js

@@ -5,11 +5,18 @@
 
 "use strict";
 
-/** @typedef {import("../../declarations/WebpackOptions").RuleSetConditionOrConditions} RuleSetConditionOrConditions */
-/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
-/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
-/** @typedef {import("./RuleSetCompiler").EffectData} EffectData */
-/** @typedef {import("./RuleSetCompiler").RuleConditionFunction} RuleConditionFunction */
+/**
+ * @import {
+ * 	RuleSetConditionOrConditions,
+ * 	RuleSetRule
+ * } from "../../declarations/WebpackOptions"
+ */
+/**
+ * @import RuleSetCompiler, {
+ * 	EffectData,
+ * 	RuleConditionFunction
+ * } from "./RuleSetCompiler"
+ */
 
 /**
  * Defines the keys of types type used by this module.

package/lib/rules/RuleSetCompiler.js

@@ -6,13 +6,18 @@
 "use strict";
 
 const { SyncHook } = require("tapable");
+const { createPathGlobMatcher } = require("../util/globUtils");
 
-/** @typedef {import("enhanced-resolve").ResolveRequest} ResolveRequest */
-/** @typedef {import("../../declarations/WebpackOptions").Falsy} Falsy */
-/** @typedef {import("../../declarations/WebpackOptions").RuleSetUseItem} RuleSetUseItem */
-/** @typedef {import("../../declarations/WebpackOptions").RuleSetLoaderOptions} RuleSetLoaderOptions */
-/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
-/** @typedef {import("../../declarations/WebpackOptions").RuleSetConditionAbsolute} RuleSetConditionAbsolute */
+/** @import { ResolveRequest } from "enhanced-resolve" */
+/**
+ * @import {
+ * 	Falsy,
+ * 	RuleSetUseItem,
+ * 	RuleSetLoaderOptions,
+ * 	RuleSetRule,
+ * 	RuleSetConditionAbsolute
+ * } from "../../declarations/WebpackOptions"
+ */
 
 /** @typedef {(Falsy | RuleSetRule)[]} RuleSetRules */
 
@@ -48,6 +53,7 @@ const { SyncHook } = require("tapable");
  * @property {string=} mimetype
  * @property {string} dependency
  * @property {ResolveRequest["descriptionFileData"]=} descriptionData
+ * @property {ResolveRequest["relativePath"]=} descriptionRelativePath
  * @property {string=} compiler
  * @property {string} issuer
  * @property {string} issuerLayer
@@ -57,6 +63,9 @@ const { SyncHook } = require("tapable");
 /**
  * Defines the compiled rule type used by this module.
  * @typedef {object} CompiledRule
+ * @property {string} path
+ * @property {RuleSetRule} raw
+ * @property {boolean} used
  * @property {RuleCondition[]} conditions
  * @property {(Effect | ((effectData: EffectData) => Effect[]))[]} effects
  * @property {CompiledRule[]=} rules
@@ -88,6 +97,7 @@ const { SyncHook } = require("tapable");
  * @typedef {object} RuleSet
  * @property {References} references map of references in the rule set (may grow over time)
  * @property {(effectData: EffectData) => Effect[]} exec execute the rule set
+ * @property {() => CompiledRule[]} unusedRules the rules that never matched, outermost first
  */
 
 /**
@@ -99,11 +109,34 @@ const { SyncHook } = require("tapable");
 
 /** @typedef {Set<string>} UnhandledProperties */
 
+/** @typedef {(str: string) => boolean} GlobMatcher */
 /** @typedef {(data: EffectData) => (RuleSetUseItem | (Falsy | RuleSetUseItem)[])} RuleSetUseFn */
 /** @typedef {(value: string) => boolean} RuleSetConditionFn */
 
 /** @typedef {{ apply: (ruleSetCompiler: RuleSetCompiler) => void }} RuleSetPlugin */
 
+/**
+ * @param {GlobMatcher[]} positive patterns that select
+ * @param {GlobMatcher[]} negative patterns that subtract
+ * @returns {GlobMatcher} matcher
+ */
+const combineGlobMatchers = (positive, negative) => {
+	/** @type {GlobMatcher} */
+	const matchPositive =
+		positive.length === 0
+			? () => true
+			: positive.length === 1
+				? positive[0]
+				: (str) => positive.some((match) => match(str));
+	if (negative.length === 0) return matchPositive;
+	/** @type {GlobMatcher} */
+	const matchNegative =
+		negative.length === 1
+			? negative[0]
+			: (str) => negative.some((match) => match(str));
+	return (str) => matchPositive(str) && !matchNegative(str);
+};
+
 class RuleSetCompiler {
 	/**
 	 * Creates an instance of RuleSetCompiler.
@@ -177,6 +210,7 @@ class RuleSetCompiler {
 					return false;
 				}
 			}
+			rule.used = true;
 			for (const effect of rule.effects) {
 				if (typeof effect === "function") {
 					const returnedEffects = effect(data);
@@ -211,6 +245,12 @@ class RuleSetCompiler {
 					execRule(data, rule, effects);
 				}
 				return effects;
+			},
+			unusedRules: () => {
+				/** @type {CompiledRule[]} */
+				const unused = [];
+				collectUnusedRules(rules, unused);
+				return unused;
 			}
 		};
 	}
@@ -251,6 +291,9 @@ class RuleSetCompiler {
 
 		/** @type {CompiledRule} */
 		const compiledRule = {
+			path,
+			raw: rule,
+			used: false,
 			conditions: [],
 			effects: [],
 			rules: undefined,
@@ -382,6 +425,11 @@ class RuleSetCompiler {
 						}
 					}
 					break;
+				case "glob":
+					if (value) {
+						conditions.push(this.compileGlobCondition(`${path}.glob`, value));
+					}
+					break;
 				case "not":
 					if (value) {
 						const matcher = this.compileCondition(`${path}.not`, value);
@@ -410,6 +458,49 @@ class RuleSetCompiler {
 		return this.combineConditionsAnd(conditions);
 	}
 
+	/**
+	 * Returns a compiled glob condition. Unlike a regexp it matches the same way
+	 * on every OS: `\` is a path separator in both the pattern and the tested
+	 * value, and a relative pattern matches at any depth. Patterns are OR-ed,
+	 * a `!` prefix subtracts, and a list of only `!` patterns subtracts from
+	 * everything.
+	 * @param {string} path current path
+	 * @param {string | string[]} glob user provided glob pattern(s)
+	 * @returns {Condition} compiled condition
+	 */
+	compileGlobCondition(path, glob) {
+		const globs = Array.isArray(glob) ? glob : [glob];
+		if (globs.length === 0) {
+			throw this.error(path, glob, "Expected glob pattern, but got empty list");
+		}
+		/** @type {GlobMatcher[]} */
+		const positive = [];
+		/** @type {GlobMatcher[]} */
+		const negative = [];
+		for (let i = 0; i < globs.length; i++) {
+			const pattern = globs[i];
+			const patternPath = Array.isArray(glob) ? `${path}[${i}]` : path;
+			if (typeof pattern !== "string") {
+				throw this.error(
+					patternPath,
+					pattern,
+					`Unexpected ${typeof pattern} when glob pattern was expected`
+				);
+			}
+			const negated = pattern.startsWith("!");
+			const match = createPathGlobMatcher(negated ? pattern.slice(1) : pattern);
+			if (match === null) {
+				throw this.error(patternPath, pattern, "Invalid glob pattern");
+			}
+			(negated ? negative : positive).push(match);
+		}
+		const match = combineGlobMatchers(positive, negative);
+		return {
+			matchWhenEmpty: match(""),
+			fn: (v) => typeof v === "string" && match(v)
+		};
+	}
+
 	/**
 	 * Combine conditions or.
 	 * @param {Condition[]} conditions some conditions
@@ -477,7 +568,8 @@ class RuleSetCompiler {
 	 * are ignored: they don't establish the module type (e.g. a stylelint pre-loader
 	 * must not suppress the built-in css type). A `test` regexp that references the
 	 * extension (e.g. `/source\.css$/`) also counts even if the sample path itself
-	 * doesn't match, so a loader scoped to specific filenames is still detected.
+	 * doesn't match, so a loader scoped to specific filenames is still detected; a
+	 * `glob` condition naming the extension counts the same way.
 	 * @param {import("../../declarations/WebpackOptions").RuleSetRules | undefined} rules user `module.rules`
 	 * @param {string} resource sample resource path (e.g. `"/file.css"`)
 	 * @param {boolean=} inherited whether an enclosing rule already matched the resource
@@ -493,7 +585,13 @@ class RuleSetCompiler {
 				inherited ||
 				matchesResource(rule.test, resource, extProbe) ||
 				matchesResource(rule.resource, resource, extProbe) ||
-				matchesResource(rule.include, resource, extProbe);
+				matchesResource(rule.include, resource, extProbe) ||
+				// the rule-level `glob` selects the resource as well
+				matchesResource(
+					rule.glob === undefined ? undefined : { glob: rule.glob },
+					resource,
+					extProbe
+				);
 			const establishesType =
 				rule.type !== undefined ||
 				((rule.use !== undefined || rule.loader !== undefined) &&
@@ -543,9 +641,25 @@ const matchRuleSetCondition = (condition, resource) => {
 };
 
 /**
- * Whether any regexp in the condition references the extension probe (e.g.
- * `\.css`), i.e. the rule clearly targets that extension even if the generic
- * sample path doesn't match its (possibly filename-scoped) pattern.
+ * @param {EXPECTED_ANY} glob glob pattern(s)
+ * @param {string} extension extension including the dot (e.g. `".css"`)
+ * @returns {boolean} whether a pattern targets the extension
+ */
+const globReferencesExtension = (glob, extension) => {
+	// a `!` pattern subtracts the extension instead of targeting it
+	if (typeof glob === "string") {
+		return !glob.startsWith("!") && glob.includes(extension);
+	}
+	return (
+		Array.isArray(glob) &&
+		glob.some((pattern) => globReferencesExtension(pattern, extension))
+	);
+};
+
+/**
+ * Whether any regexp or glob in the condition references the extension probe
+ * (e.g. `\.css`), i.e. the rule clearly targets that extension even if the
+ * generic sample path doesn't match its (possibly filename-scoped) pattern.
  * @param {EXPECTED_ANY} condition condition
  * @param {string} extProbe escaped extension probe (e.g. `"\\.css"`)
  * @returns {boolean} whether a regexp in the condition targets the extension
@@ -557,6 +671,8 @@ const conditionReferencesExtension = (condition, extProbe) => {
 	}
 	if (condition && typeof condition === "object") {
 		return (
+			// `\.css` → `.css`
+			globReferencesExtension(condition.glob, extProbe.slice(1)) ||
 			conditionReferencesExtension(condition.and, extProbe) ||
 			conditionReferencesExtension(condition.or, extProbe)
 		);
@@ -566,7 +682,7 @@ const conditionReferencesExtension = (condition, extProbe) => {
 
 /**
  * A condition counts as targeting the resource if it matches the sample path or
- * references the extension via a regexp.
+ * references the extension via a regexp or glob.
  * @param {RuleSetConditionAbsolute | undefined} condition condition
  * @param {string} resource sample resource path
  * @param {string} extProbe escaped extension probe (e.g. `"\\.css"`)
@@ -577,4 +693,22 @@ const matchesResource = (condition, resource, extProbe) =>
 	(matchRuleSetCondition(condition, resource) ||
 		conditionReferencesExtension(condition, extProbe));
 
+/**
+ * Collects the outermost rules that never matched. A rule below an unused one is
+ * unused only because of its parent, so its subtree is not descended into.
+ * @param {CompiledRule[]} rules compiled rules
+ * @param {CompiledRule[]} result where unused rules are collected
+ * @returns {void}
+ */
+const collectUnusedRules = (rules, result) => {
+	for (const rule of rules) {
+		if (!rule.used) {
+			result.push(rule);
+			continue;
+		}
+		if (rule.rules) collectUnusedRules(rule.rules, result);
+		if (rule.oneOf) collectUnusedRules(rule.oneOf, result);
+	}
+};
+
 module.exports = RuleSetCompiler;

package/lib/rules/UseEffectRulePlugin.js

@@ -7,17 +7,24 @@
 
 const util = require("util");
 
-/** @typedef {import("../../declarations/WebpackOptions").Falsy} Falsy */
-/** @typedef {import("../../declarations/WebpackOptions").RuleSetLoader} RuleSetLoader */
-/** @typedef {import("../../declarations/WebpackOptions").RuleSetLoaderOptions} RuleSetLoaderOptions */
-/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
-/** @typedef {import("../../declarations/WebpackOptions").RuleSetUse} RuleSetUse */
-/** @typedef {import("../../declarations/WebpackOptions").RuleSetUseItem} RuleSetUseItem */
-/** @typedef {import("../../declarations/WebpackOptions").RuleSetUseFunction} RuleSetUseFunction */
-/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
-/** @typedef {import("./RuleSetCompiler").Effect} Effect */
-/** @typedef {import("./RuleSetCompiler").EffectData} EffectData */
-/** @typedef {import("./RuleSetCompiler").EffectUseType} EffectUseType */
+/**
+ * @import {
+ * 	Falsy,
+ * 	RuleSetLoader,
+ * 	RuleSetLoaderOptions,
+ * 	RuleSetRule,
+ * 	RuleSetUse,
+ * 	RuleSetUseItem,
+ * 	RuleSetUseFunction
+ * } from "../../declarations/WebpackOptions"
+ */
+/**
+ * @import RuleSetCompiler, {
+ * 	Effect,
+ * 	EffectData,
+ * 	EffectUseType
+ * } from "./RuleSetCompiler"
+ */
 
 const PLUGIN_NAME = "UseEffectRulePlugin";
 

package/lib/runtime/AsyncModuleGeneratorRuntimeModule.js

@@ -8,13 +8,23 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const HelperRuntimeModule = require("./HelperRuntimeModule");
 
-/** @typedef {import("../Compilation")} Compilation */
+/** @import Compilation from "../Compilation" */
 
 class AsyncModuleGeneratorRuntimeModule extends HelperRuntimeModule {
 	constructor() {
 		super("async module generator");
 	}
 
+	/**
+	 * Returns true, if the runtime module should get it's own scope.
+	 * When false, `generate()` must emit complete statements ending with `;`
+	 * so a following runtime IIFE is not parsed as a call (ASI).
+	 * @returns {boolean} true, if the runtime module should get it's own scope
+	 */
+	shouldIsolate() {
+		return false;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code