@@ -0,0 +1,5 @@
+---
+"webpack": patch
+---
+
+Read the extension out of a path-scoped rule's alternation, class or braces.
@@ -640,6 +640,200 @@ const matchRuleSetCondition = (condition, resource) => {
 	}
 };
 
+// Cap on the spellings one pattern is expanded into, so a pattern built from
+// many alternations stays cheap to probe.
+const MAX_EXPANDED_SPELLINGS = 64;
+
+// A rule naming an extension is short; a pattern generated from a list of paths
+// runs to kilobytes and costs more to expand than the answer is worth.
+const MAX_EXPANDED_PATTERN_LENGTH = 256;
+
+/**
+ * Index of the `]` closing the character class opened at `start`, or the end of
+ * the source when it is unterminated.
+ * @param {string} source regexp source
+ * @param {number} start index of the opening `[`
+ * @returns {number} index of the closing `]`
+ */
+const findCharacterClassEnd = (source, start) => {
+	for (let i = start + 1; i < source.length; i++) {
+		if (source[i] === "\\") i++;
+		else if (source[i] === "]") return i;
+	}
+	return source.length;
+};
+
+/**
+ * Index of the `)` closing the group opened at `start`, skipping nested groups
+ * and character classes, or the end of the source when it is unterminated.
+ * @param {string} source regexp source
+ * @param {number} start index of the opening `(`
+ * @returns {number} index of the closing `)`
+ */
+const findGroupEnd = (source, start) => {
+	let depth = 0;
+	for (let i = start; i < source.length; i++) {
+		const char = source[i];
+		if (char === "\\") i++;
+		else if (char === "[") i = findCharacterClassEnd(source, i);
+		else if (char === "(") depth++;
+		else if (char === ")" && --depth === 0) return i;
+	}
+	return source.length;
+};
+
+/**
+ * Splits a group body on its top-level `|`, skipping nested groups and
+ * character classes.
+ * @param {string} body group body without the enclosing parentheses
+ * @returns {string[]} the alternatives
+ */
+const splitAlternatives = (body) => {
+	const alternatives = [];
+	let depth = 0;
+	let start = 0;
+	for (let i = 0; i < body.length; i++) {
+		const char = body[i];
+		if (char === "\\") {
+			i++;
+		} else if (char === "[") {
+			i = findCharacterClassEnd(body, i);
+		} else if (char === "(") {
+			depth++;
+		} else if (char === ")") {
+			depth--;
+		} else if (char === "|" && depth === 0) {
+			alternatives.push(body.slice(start, i));
+			start = i + 1;
+		}
+	}
+	alternatives.push(body.slice(start));
+	return alternatives;
+};
+
+/**
+ * The part of a group body that the match spells — past a `?:` or `?<name>`
+ * prefix, and nothing at all for a lookaround, which spells nothing.
+ * @param {string} body group body without the enclosing parentheses
+ * @returns {string | undefined} the spelled part, or `undefined` for a lookaround
+ */
+const groupContent = (body) => {
+	if (!body.startsWith("?")) return body;
+	if (body.startsWith("?:")) return body.slice(2);
+	const named = /^\?<[^=!][^>]*>/.exec(body);
+	return named ? body.slice(named[0].length) : undefined;
+};
+
+/**
+ * Rewrites the first group, word-character class or optional atom
+ * in the source into the spellings it can match, leaving the rest as written.
+ * @param {string} source regexp source
+ * @returns {string[] | undefined} the rewritten sources, or `undefined` when the source holds no such construct
+ */
+const expandFirstConstruct = (source) => {
+	for (let i = 0; i < source.length; i++) {
+		const char = source[i];
+		let end = i + 1;
+		/** @type {string[] | undefined} */
+		let spellings;
+		if (char === "\\") {
+			end = i + 2;
+		} else if (char === "[") {
+			const close = findCharacterClassEnd(source, i);
+			end = close + 1;
+			const body = source.slice(i + 1, close);
+			// only a plain list of word characters spells out safely (no range,
+			// no negation, no escape)
+			if (/^\w+$/.test(body)) spellings = [...body];
+		} else if (char === "(") {
+			const close = findGroupEnd(source, i);
+			end = close + 1;
+			const content = groupContent(source.slice(i + 1, close));
+			if (content !== undefined) spellings = splitAlternatives(content);
+		}
+		// `?` makes the atom optional, so its absence is a spelling as well
+		if (source[end] === "?") {
+			spellings = [...(spellings || [source.slice(i, end)]), ""];
+			end += 1;
+		}
+		if (spellings) {
+			return spellings.map(
+				(spelling) => source.slice(0, i) + spelling + source.slice(end)
+			);
+		}
+		i = end - 1;
+	}
+};
+
+/**
+ * Rewrites the first brace alternative in a glob pattern (e.g. `*.{css,scss}`)
+ * into the spellings it can match.
+ * @param {string} pattern glob pattern
+ * @returns {string[] | undefined} the rewritten patterns, or `undefined` when the pattern holds no brace
+ */
+const expandFirstBrace = (pattern) => {
+	const open = pattern.indexOf("{");
+	const close = open === -1 ? -1 : pattern.indexOf("}", open);
+	if (close === -1) return;
+	return pattern
+		.slice(open + 1, close)
+		.split(",")
+		.map(
+			(alternative) =>
+				pattern.slice(0, open) + alternative + pattern.slice(close + 1)
+		);
+};
+
+/**
+ * Whether `probe` occurs in `pattern` as a subsequence. Expanding a pattern only
+ * ever drops characters, so a probe failing this is spelled by none of its
+ * spellings and the expansion is not worth starting.
+ * @param {string} pattern pattern to search
+ * @param {string} probe probe to find
+ * @returns {boolean} whether the probe is a subsequence of the pattern
+ */
+const containsSubsequence = (pattern, probe) => {
+	let found = 0;
+	for (let i = 0; i < pattern.length && found < probe.length; i++) {
+		if (pattern[i] === probe[found]) found++;
+	}
+	return found === probe.length;
+};
+
+/**
+ * Whether any spelling of the pattern contains the probe, rewriting one
+ * construct at a time until none is left or `MAX_EXPANDED_SPELLINGS` is reached.
+ * @param {string} pattern pattern to expand
+ * @param {string} probe probe the spellings are searched for
+ * @param {(pattern: string) => string[] | undefined} expandFirst rewrites the first expandable construct
+ * @returns {boolean} whether a spelling contains the probe
+ */
+const someSpellingContains = (pattern, probe, expandFirst) => {
+	if (pattern.includes(probe)) return true;
+	if (pattern.length > MAX_EXPANDED_PATTERN_LENGTH) return false;
+	if (!containsSubsequence(pattern, probe)) return false;
+	let spellings = [pattern];
+	for (;;) {
+		/** @type {string[]} */
+		const expanded = [];
+		for (const spelling of spellings) {
+			const rewritten = expandFirst(spelling);
+			// every spelling was searched as it was produced, so one with nothing
+			// left to rewrite is settled
+			if (!rewritten) continue;
+			for (const alternative of rewritten) {
+				if (alternative.includes(probe)) return true;
+				// an alternative that dropped the probe's characters expands no
+				// further into it
+				if (containsSubsequence(alternative, probe)) expanded.push(alternative);
+			}
+			if (expanded.length > MAX_EXPANDED_SPELLINGS) return false;
+		}
+		if (expanded.length === 0) return false;
+		spellings = expanded;
+	}
+};
+
 /**
  * @param {EXPECTED_ANY} glob glob pattern(s)
  * @param {string} extension extension including the dot (e.g. `".css"`)
@@ -648,7 +842,10 @@ const matchRuleSetCondition = (condition, resource) => {
 const globReferencesExtension = (glob, extension) => {
 	// a `!` pattern subtracts the extension instead of targeting it
 	if (typeof glob === "string") {
-		return !glob.startsWith("!") && glob.includes(extension);
+		return (
+			!glob.startsWith("!") &&
+			someSpellingContains(glob, extension, expandFirstBrace)
+		);
 	}
 	return (
 		Array.isArray(glob) &&
@@ -660,12 +857,20 @@ const globReferencesExtension = (glob, 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.
+ * The extension may be spelled by an alternation (`\.(css|scss)$`) or a
+ * character class (`\.[jt]sx?$`), so those are expanded before probing.
  * @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
  */
 const conditionReferencesExtension = (condition, extProbe) => {
-	if (condition instanceof RegExp) return condition.source.includes(extProbe);
+	if (condition instanceof RegExp) {
+		// an `/i` rule spells the extension in any case; the probe is lower case
+		const source = condition.ignoreCase
+			? condition.source.toLowerCase()
+			: condition.source;
+		return someSpellingContains(source, extProbe, expandFirstConstruct);
+	}
 	if (Array.isArray(condition)) {
 		return condition.some((c) => conditionReferencesExtension(c, extProbe));
 	}
 
@@ -5825,6 +5825,41 @@ describe("experiments.css/html/asyncWebAssembly auto", () => {
 		).toEqual({ css: "auto", html: "auto", asyncWebAssembly: true });
 	});
 
+	it("reads the extension out of a path-scoped alternation or class", () => {
+		// The sample path the detection probes with doesn't match a path-scoped
+		// rule, so the extension has to be read out of the pattern itself.
+		expect(
+			resolve({
+				module: {
+					rules: [
+						{
+							test: /[\\/]src[\\/].*\.(css|scss)$/i,
+							use: ["style-loader", "css-loader"]
+						}
+					]
+				}
+			})
+		).toEqual({ css: false, html: "auto", asyncWebAssembly: true });
+		expect(
+			resolve({
+				module: {
+					rules: [
+						{ glob: "src/**/*.{css,scss}", use: ["style-loader", "css-loader"] }
+					]
+				}
+			})
+		).toEqual({ css: false, html: "auto", asyncWebAssembly: true });
+		expect(
+			resolve({
+				module: {
+					rules: [
+						{ test: /\/templates\/.*\.(html|htm)$/i, use: ["html-loader"] }
+					]
+				}
+			})
+		).toEqual({ css: "auto", html: false, asyncWebAssembly: true });
+	});
+
 	it("stays lenient about include/exclude narrowing", () => {
 		// A loader scoped to `include: /src/` already handles those files today, so
 		// the built-in type must stay off even for a resource outside that scope.
@@ -5955,12 +5990,36 @@ describe("experiments.typescript auto", () => {
 		).toBe(false);
 	});
 
+	it("keeps typescript off for a path-scoped ts-loader rule", () => {
+		// A rule the sample path can't match still names `.ts` in its alternation
+		// or class — leaving the built-in support on would reject `.tsx` outright.
+		expect(
+			resolve({
+				module: {
+					rules: [{ test: /\/components\/.*\.(ts|tsx)$/, use: ["ts-loader"] }]
+				}
+			})
+		).toBe(false);
+		expect(
+			resolve({
+				module: { rules: [{ test: /[\\/]src[\\/].*\.[jt]sx?$/, use: ["swc"] }] }
+			})
+		).toBe(false);
+	});
+
 	it("ignores loaders registered for unrelated extensions", () => {
 		expect(
 			resolve({
 				module: { rules: [{ test: /\.js$/i, use: ["babel-loader"] }] }
 			})
 		).toBe(true);
+		expect(
+			resolve({
+				module: {
+					rules: [{ test: /[\\/]src[\\/].*\.(js|mjs)$/, use: ["babel-loader"] }]
+				}
+			})
+		).toBe(true);
 	});
 
 	it("keeps typescript off when the Node.js TypeScript API is unavailable", () => {
-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +"webpack": patch
 +---
++
 +Read the extension out of a path-scoped rule's alternation, class or braces.