@flint.fyi/ts 0.14.6 → 0.18.0

package/lib/rules/regexMisleadingCapturingGroups.js

@@ -0,0 +1,229 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { parseRegexpAst } from "./utils/parseRegexpAst.js";
+import { getRegExpConstruction } from "./utils/getRegExpConstruction.js";
+import { getRegExpLiteralDetails } from "./utils/getRegExpLiteralDetails.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import { visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexMisleadingCapturingGroups.ts
+function collectFromElement(element, collector) {
+	const result = /* @__PURE__ */ new Set();
+	forEachInGroup(element, (element) => {
+		for (const item of collector(element)) result.add(item);
+	});
+	return result;
+}
+function elementContainsPositiveSet(element, kind) {
+	return forEachInGroup(element, (el) => el.type === "CharacterSet" && hasNegate(el) && el.kind === kind && !el.negate);
+}
+function findFollowingElement(capturingGroup) {
+	const info = getAlternativeIndex(capturingGroup);
+	return info?.elements[info.index + 1];
+}
+function findPrecedingQuantifier(capturingGroup) {
+	const info = getAlternativeIndex(capturingGroup);
+	if (!info || info.index <= 0) return;
+	const previous = info.elements[info.index - 1];
+	return previous?.type === "Quantifier" && previous.max > previous.min ? previous : void 0;
+}
+function forEachInGroup(element, callback) {
+	switch (element.type) {
+		case "CapturingGroup":
+		case "Group":
+			for (const alt of element.alternatives) for (const el of alt.elements) if (forEachInGroup(el, callback)) return true;
+			return false;
+		case "Quantifier": return forEachInGroup(element.element, callback);
+		default: return callback(element) === true;
+	}
+}
+function getAlternativeIndex(capturingGroup) {
+	const parent = capturingGroup.parent;
+	if (parent.type !== "Alternative") return;
+	const index = parent.elements.indexOf(capturingGroup);
+	return index === -1 ? void 0 : {
+		elements: parent.elements,
+		index
+	};
+}
+function getCharacterSetType(el) {
+	if (el.kind === "any") return "set:any";
+	if (!hasNegate(el)) return "";
+	return `set:${el.kind}${el.negate ? ":negated" : ""}`;
+}
+function getCharacterValues(elements) {
+	const result = [];
+	for (const el of elements) if (el.type === "Character") result.push(el.value);
+	return result;
+}
+function getClassExcludedChars(element) {
+	if (element.type !== "CharacterClass" || !element.negate) return /* @__PURE__ */ new Set();
+	return new Set(getCharacterValues(element.elements));
+}
+function getElementCharacters(element) {
+	return collectFromElement(element, (el) => {
+		if (el.type === "Character") return [el.value];
+		if (el.type === "CharacterClass") return getCharacterValues(el.elements);
+		return [];
+	});
+}
+function getEndQuantifier(capturingGroup) {
+	for (const alternative of capturingGroup.alternatives) {
+		if (!alternative.elements.length) continue;
+		const last = alternative.elements.at(-1);
+		if (last.type === "Quantifier" && last.max > last.min) return last;
+	}
+}
+function getFirstElementInGroup(element) {
+	let current = element;
+	while (current) {
+		if (current.type === "Quantifier") {
+			current = current.element;
+			continue;
+		}
+		if (current.type === "Group" || current.type === "CapturingGroup") {
+			const alternative = current.alternatives[0];
+			if (!alternative) return;
+			current = alternative.elements[0];
+			continue;
+		}
+		break;
+	}
+	return current;
+}
+function getMatchableCharacterTypes(element) {
+	return collectFromElement(element, (el) => {
+		if (el.type === "Character") return [`char:${el.value}`];
+		if (el.type === "CharacterSet") {
+			const type = getCharacterSetType(el);
+			return type ? [type] : [];
+		}
+		if (el.type === "CharacterClass") return el.elements.flatMap((child) => {
+			if (child.type === "Character") return [`char:${child.value}`];
+			if (child.type === "CharacterSet" && hasNegate(child)) return [`set:${child.kind}${child.negate ? ":negated" : ""}`];
+			if (child.type === "CharacterClassRange") return [`range:${child.min.value}-${child.max.value}`];
+			return [];
+		});
+		return [];
+	});
+}
+function getStartQuantifier(alternative, direction) {
+	const elements = alternative.elements;
+	if (!elements.length) return;
+	const first = direction === "ltr" ? elements[0] : elements.at(-1);
+	if (!first) return;
+	if (first.type === "Quantifier") return first;
+	if (first.type === "Group") for (const alt of first.alternatives) {
+		const quantifier = getStartQuantifier(alt, direction);
+		if (quantifier) return quantifier;
+	}
+}
+function hasNegate(node) {
+	return "negate" in node;
+}
+function hasOverlap(a, b) {
+	if (a.has("set:any") || b.has("set:any")) return true;
+	for (const type of a) if (b.has(type)) return true;
+	return false;
+}
+function isAllowedEndPattern(endQuantifier, followingElement) {
+	return isDotDelimiterPattern(endQuantifier, followingElement) || isNegatedSetFollowedByPositive(endQuantifier, followingElement) || isExcludedDelimiterPattern(endQuantifier, followingElement);
+}
+function isDotDelimiterPattern(endQuantifier, followingElement) {
+	return endQuantifier.element.type === "CharacterSet" && endQuantifier.element.kind === "any" && followingElement.type === "Character";
+}
+function isExcludedDelimiterPattern(endQuantifier, followingElement) {
+	if (endQuantifier.element.type !== "CharacterClass" || !endQuantifier.element.negate) return false;
+	const excluded = getClassExcludedChars(endQuantifier.element);
+	if (!excluded.size) return false;
+	const followingChars = getElementCharacters(followingElement);
+	for (const character of followingChars) if (excluded.has(character)) return true;
+	return false;
+}
+function isNegatedSetFollowedByPositive(endQuantifier, followingElement) {
+	return endQuantifier.element.type === "CharacterSet" && hasNegate(endQuantifier.element) && endQuantifier.element.negate && elementContainsPositiveSet(followingElement, endQuantifier.element.kind);
+}
+var regexMisleadingCapturingGroups_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports capturing groups that capture less text than their pattern suggests.",
+		id: "regexMisleadingCapturingGroups",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: {
+		misleadingEnd: {
+			primary: "Quantifier '{{ quantifierRaw }}' at the end of capturing group may capture less than expected due to backtracking.",
+			secondary: ["The quantifier at the end of this capturing group may give up characters during backtracking to satisfy a following pattern."],
+			suggestions: ["Use an atomic group.", "Rewrite the pattern."]
+		},
+		misleadingStart: {
+			primary: "Capturing group with '{{ captureRaw }}' will always capture {{ behavior }} because '{{ precedingRaw }}' consumes matching characters first.",
+			secondary: ["The quantifier in this capturing group can never match as much as expected because a preceding quantifier already consumed the characters."],
+			suggestions: ["Remove the quantifier in the capturing group.", "Simplify the quantifier in the capturing group."]
+		}
+	},
+	setup(context) {
+		function checkPattern(pattern, patternStart, flags) {
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			visitRegExpAST(regexpAst, { onCapturingGroupEnter(cgNode) {
+				checkMisleadingStart(cgNode, patternStart);
+				checkMisleadingEnd(cgNode, patternStart);
+			} });
+		}
+		function checkMisleadingStart(capturingGroupNode, patternStart) {
+			const precedingQuantifier = findPrecedingQuantifier(capturingGroupNode);
+			const firstAlternative = capturingGroupNode.alternatives[0];
+			if (!precedingQuantifier || !firstAlternative) return;
+			const startQuantifier = getStartQuantifier(firstAlternative, "ltr");
+			if (!startQuantifier) return;
+			if (startQuantifier.element.type === "CharacterSet" && startQuantifier.element.kind === "any") return;
+			if (!hasOverlap(getMatchableCharacterTypes(precedingQuantifier.element), getMatchableCharacterTypes(startQuantifier.element))) return;
+			const behavior = startQuantifier.min === 0 ? "the empty string" : `only ${startQuantifier.min} character${startQuantifier.min > 1 ? "s" : ""}`;
+			context.report({
+				data: {
+					behavior,
+					captureRaw: startQuantifier.raw,
+					precedingRaw: precedingQuantifier.raw
+				},
+				message: "misleadingStart",
+				range: {
+					begin: patternStart + startQuantifier.start,
+					end: patternStart + startQuantifier.end
+				}
+			});
+		}
+		function checkMisleadingEnd(capturingGroupNode, patternStart) {
+			const endQuantifier = getEndQuantifier(capturingGroupNode);
+			if (!endQuantifier) return;
+			const followingElement = findFollowingElement(capturingGroupNode);
+			if (!followingElement || isAllowedEndPattern(endQuantifier, followingElement)) return;
+			const endTypes = getMatchableCharacterTypes(endQuantifier.element);
+			const firstFollowing = getFirstElementInGroup(followingElement);
+			if (!hasOverlap(endTypes, firstFollowing ? getMatchableCharacterTypes(firstFollowing) : /* @__PURE__ */ new Set())) return;
+			context.report({
+				data: { quantifierRaw: endQuantifier.raw },
+				message: "misleadingEnd",
+				range: {
+					begin: patternStart + endQuantifier.start,
+					end: patternStart + endQuantifier.end
+				}
+			});
+		}
+		function checkRegexLiteral(node, services) {
+			const details = getRegExpLiteralDetails(node, services);
+			checkPattern(details.pattern, details.start, details.flags);
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			checkPattern(construction.raw, construction.start + 1, construction.flags);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexMisleadingCapturingGroups_default as default };
+
+//# sourceMappingURL=regexMisleadingCapturingGroups.js.map

package/lib/rules/regexMisleadingQuantifiers.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports quantifiers whose minimum implies they must match but whose element can match empty.";
+    readonly id: "regexMisleadingQuantifiers";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "confusing", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexMisleadingQuantifiers.d.ts.map

package/lib/rules/regexMisleadingQuantifiers.js

@@ -0,0 +1,78 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { parseRegexpAst } from "./utils/parseRegexpAst.js";
+import { getRegExpConstruction } from "./utils/getRegExpConstruction.js";
+import { getRegExpLiteralDetails } from "./utils/getRegExpLiteralDetails.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import { visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexMisleadingQuantifiers.ts
+function formatQuantifier(min, max, greedy) {
+	let result;
+	if (min === 0 && max === 1) result = "?";
+	else if (min === 0 && max === Infinity) result = "*";
+	else if (min === 1 && max === Infinity) result = "+";
+	else if (min === max) result = `{${min}}`;
+	else if (max === Infinity) result = `{${min},}`;
+	else result = `{${min},${max}}`;
+	return greedy ? result : `${result}?`;
+}
+function isPotentiallyEmpty(element) {
+	switch (element.type) {
+		case "Assertion":
+		case "Backreference": return true;
+		case "CapturingGroup":
+		case "Group": return element.alternatives.some((alt) => alt.elements.every((el) => isPotentiallyEmpty(el)));
+		case "Quantifier": return element.min === 0 || isPotentiallyEmpty(element.element);
+		default: return false;
+	}
+}
+var regexMisleadingQuantifiers_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports quantifiers whose minimum implies they must match but whose element can match empty.",
+		id: "regexMisleadingQuantifiers",
+		presets: ["logical"]
+	},
+	messages: { confusing: {
+		primary: "Quantifier minimum is {{ min }} but the element can match empty. Consider using '{{ proposal }}' instead.",
+		secondary: ["This quantifier suggests it must match at least {{ min }} time(s), but the quantified element can match the empty string, so the effective minimum is 0."],
+		suggestions: ["Replace the quantifier with one that reflects the actual minimum."]
+	} },
+	setup(context) {
+		function checkPattern(pattern, patternStart, flags) {
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			visitRegExpAST(regexpAst, { onQuantifierEnter(qNode) {
+				if (qNode.min <= 0 || !isPotentiallyEmpty(qNode.element)) return;
+				const proposal = formatQuantifier(0, qNode.max, qNode.greedy);
+				context.report({
+					data: {
+						min: qNode.min,
+						proposal
+					},
+					message: "confusing",
+					range: {
+						begin: patternStart + qNode.start,
+						end: patternStart + qNode.end
+					}
+				});
+			} });
+		}
+		function checkRegexLiteral(node, { sourceFile }) {
+			const details = getRegExpLiteralDetails(node, { sourceFile });
+			checkPattern(details.pattern, details.start, details.flags);
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			checkPattern(construction.pattern, construction.start + 1, construction.flags);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexMisleadingQuantifiers_default as default };
+
+//# sourceMappingURL=regexMisleadingQuantifiers.js.map

package/lib/rules/regexMisleadingUnicodeCharacters.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports characters in regex character classes that appear as single visual characters but are made of multiple code points.";
+    readonly id: "regexMisleadingUnicodeCharacters";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "combiningClass" | "emojiModifier" | "regionalIndicatorSymbol" | "surrogatePair" | "surrogatePairWithoutUFlag" | "zwj", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexMisleadingUnicodeCharacters.d.ts.map

package/lib/rules/regexMisleadingUnicodeCharacters.js

@@ -0,0 +1,203 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { parseRegexpAst } from "./utils/parseRegexpAst.js";
+import { getRegExpLiteralDetails } from "./utils/getRegExpLiteralDetails.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexMisleadingUnicodeCharacters.ts
+function findAllMatches(characters, hasUnicodeFlag) {
+	const matches = [];
+	if (hasUnicodeFlag) for (const nodes of findSurrogatePairs(characters)) matches.push({
+		kind: "surrogatePair",
+		nodes
+	});
+	else for (const nodes of findSurrogatePairsWithoutUFlag(characters)) matches.push({
+		kind: "surrogatePairWithoutUFlag",
+		nodes
+	});
+	for (const nodes of findCombiningClass(characters)) matches.push({
+		kind: "combiningClass",
+		nodes
+	});
+	for (const nodes of findEmojiModifiers(characters)) matches.push({
+		kind: "emojiModifier",
+		nodes
+	});
+	for (const nodes of findRegionalIndicatorSymbols(characters)) matches.push({
+		kind: "regionalIndicatorSymbol",
+		nodes
+	});
+	for (const nodes of findZeroWidthJoins(characters)) matches.push({
+		kind: "zwj",
+		nodes
+	});
+	return matches;
+}
+function* findCombiningClass(characters) {
+	for (const [index, char] of characters.entries()) {
+		const previous = characters[index - 1];
+		if (previous && isCombiningCharacter(char.value) && !isCombiningCharacter(previous.value)) yield [previous, char];
+	}
+}
+function* findEmojiModifiers(characters) {
+	for (const [index, char] of characters.entries()) {
+		const previous = characters[index - 1];
+		if (previous && isEmojiModifier(char.value) && !isEmojiModifier(previous.value)) yield [previous, char];
+	}
+}
+function* findRegionalIndicatorSymbols(characters) {
+	for (const [index, char] of characters.entries()) {
+		const previous = characters[index - 1];
+		if (previous && isRegionalIndicatorSymbol(char.value) && isRegionalIndicatorSymbol(previous.value)) yield [previous, char];
+	}
+}
+function* findSurrogatePairs(characters) {
+	for (const [index, char] of characters.entries()) {
+		const previous = characters[index - 1];
+		if (previous && isSurrogatePair(previous.value, char.value) && (isUnicodeCodePointEscape(previous) || isUnicodeCodePointEscape(char))) yield [previous, char];
+	}
+}
+function* findSurrogatePairsWithoutUFlag(characters) {
+	for (const [index, char] of characters.entries()) {
+		const previous = characters[index - 1];
+		if (previous && isSurrogatePair(previous.value, char.value) && !isUnicodeCodePointEscape(previous) && !isUnicodeCodePointEscape(char)) yield [previous, char];
+	}
+}
+function* findZeroWidthJoins(characters) {
+	let sequence;
+	for (const [index, char] of characters.entries()) {
+		const previous = characters[index - 1];
+		const next = characters[index + 1];
+		if (previous && next && char.value === 8205 && previous.value !== 8205 && next.value !== 8205) if (sequence) if (sequence.at(-1) === previous) sequence.push(char, next);
+		else {
+			yield sequence;
+			sequence = characters.slice(index - 1, index + 2);
+		}
+		else sequence = characters.slice(index - 1, index + 2);
+	}
+	if (sequence) yield sequence;
+}
+function getMessageId(kind) {
+	switch (kind) {
+		case "combiningClass": return "combiningClass";
+		case "emojiModifier": return "emojiModifier";
+		case "regionalIndicatorSymbol": return "regionalIndicatorSymbol";
+		case "surrogatePair": return "surrogatePair";
+		case "surrogatePairWithoutUFlag": return "surrogatePairWithoutUFlag";
+		case "zwj": return "zwj";
+	}
+}
+function isCombiningCharacter(codePoint) {
+	return /^[\p{Mc}\p{Me}\p{Mn}]$/u.test(String.fromCodePoint(codePoint));
+}
+function isEmojiModifier(code) {
+	return code >= 127995 && code <= 127999;
+}
+function isRegionalIndicatorSymbol(code) {
+	return code >= 127462 && code <= 127487;
+}
+function isSurrogatePair(lead, tail) {
+	return lead >= 55296 && lead < 56320 && tail >= 56320 && tail < 57344;
+}
+function isUnicodeCodePointEscape(char) {
+	return /^\\u\{[\da-f]+\}$/iu.test(char.raw);
+}
+function* iterateCharacterSequence(nodes) {
+	let sequence = [];
+	for (const node of nodes) switch (node.type) {
+		case "Character":
+			sequence.push(node);
+			break;
+		case "CharacterClass":
+		case "CharacterSet":
+		case "ClassStringDisjunction":
+		case "ExpressionCharacterClass":
+			if (sequence.length) {
+				yield sequence;
+				sequence = [];
+			}
+			break;
+		case "CharacterClassRange":
+			sequence.push(node.min);
+			yield sequence;
+			sequence = [node.max];
+			break;
+	}
+	if (sequence.length) yield sequence;
+}
+var regexMisleadingUnicodeCharacters_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports characters in regex character classes that appear as single visual characters but are made of multiple code points.",
+		id: "regexMisleadingUnicodeCharacters",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: {
+		combiningClass: {
+			primary: "Misleading combined character in character class.",
+			secondary: ["The base character and combining mark are matched separately, not as a single unit."],
+			suggestions: ["Match the composed character outside of a character class.", "Use Unicode normalization for the regular expression."]
+		},
+		emojiModifier: {
+			primary: "Misleading emoji with skin tone modifier in character class.",
+			secondary: ["The emoji and its modifier are matched separately, not as a single unit."],
+			suggestions: ["Match the emoji sequence outside of a character class."]
+		},
+		regionalIndicatorSymbol: {
+			primary: "Misleading regional indicator symbols (flag) in character class.",
+			secondary: ["The two regional indicator symbols are matched separately, not as a single flag."],
+			suggestions: ["Match the flag sequence outside of a character class."]
+		},
+		surrogatePair: {
+			primary: "Misleading surrogate pair in character class.",
+			secondary: ["The surrogate code points are represented with different escape types."],
+			suggestions: ["Use consistent escape sequences for both halves of the pair."]
+		},
+		surrogatePairWithoutUFlag: {
+			primary: "Misleading surrogate pair in character class without the `u` or `v` flag.",
+			secondary: ["Without the unicode flag, each half of the surrogate pair is matched separately."],
+			suggestions: ["Add the `u` flag to the regex."]
+		},
+		zwj: {
+			primary: "Misleading zero-width joiner sequence in character class.",
+			secondary: ["Characters joined with ZWJ are matched separately, not as a single unit.", "Consider matching the sequence outside of a character class."],
+			suggestions: ["Match the ZWJ sequence outside of a character class."]
+		}
+	},
+	setup(context) {
+		return { visitors: { RegularExpressionLiteral: (node, services) => {
+			const details = getRegExpLiteralDetails(node, services);
+			const regexpAst = parseRegexpAst(details.pattern, details.flags);
+			if (!regexpAst) return;
+			const hasUnicodeFlag = details.flags.includes("u") || details.flags.includes("v");
+			const range = getTSNodeRange(node, services.sourceFile);
+			visitRegExpAST(regexpAst, { onCharacterClassEnter(characterClassNode) {
+				for (const characters of iterateCharacterSequence(characterClassNode.elements)) {
+					const matches = findAllMatches(characters, hasUnicodeFlag);
+					for (const { kind, nodes: characters } of matches) {
+						const first = characters[0];
+						const last = characters.at(-1);
+						const messageId = getMessageId(kind);
+						context.report({
+							message: messageId,
+							range: {
+								begin: range.begin + 1 + first.start,
+								end: range.begin + 1 + last.end
+							},
+							...kind === "surrogatePairWithoutUFlag" && { suggestions: [{
+								id: "addUnicodeFlag",
+								range: {
+									begin: range.end,
+									end: range.end
+								},
+								text: "u"
+							}] }
+						});
+					}
+				}
+			} });
+		} } };
+	}
+});
+//#endregion
+export { regexMisleadingUnicodeCharacters_default as default };
+
+//# sourceMappingURL=regexMisleadingUnicodeCharacters.js.map

package/lib/rules/regexNamedBackreferences.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports backreferences that do not use the name of their referenced capturing group.";
+    readonly id: "regexNamedBackreferences";
+    readonly presets: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferNamed", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexNamedBackreferences.d.ts.map

package/lib/rules/regexNamedBackreferences.js

@@ -0,0 +1,48 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { parseRegexpAst } from "./utils/parseRegexpAst.js";
+import { getRegExpLiteralDetails } from "./utils/getRegExpLiteralDetails.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import { visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexNamedBackreferences.ts
+var regexNamedBackreferences_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports backreferences that do not use the name of their referenced capturing group.",
+		id: "regexNamedBackreferences",
+		presets: ["stylisticStrict"]
+	},
+	messages: { preferNamed: {
+		primary: "Prefer named backreference `\\k<{{ name }}>` over numeric backreference `{{ found }}`.",
+		secondary: ["Named backreferences are more readable and maintainable than numeric ones.", "If the capturing group has a name, the backreference should use that name."],
+		suggestions: ["Replace `{{ found }}` with `\\k<{{ name }}>`"]
+	} },
+	setup(context) {
+		return { visitors: { RegularExpressionLiteral: (node, { sourceFile }) => {
+			const details = getRegExpLiteralDetails(node, { sourceFile });
+			const regexpAst = parseRegexpAst(details.pattern, details.flags);
+			if (!regexpAst) return;
+			visitRegExpAST(regexpAst, { onBackreferenceEnter(backNode) {
+				if (Array.isArray(backNode.resolved) || !backNode.resolved.name || backNode.raw.startsWith("\\k<")) return;
+				const range = {
+					begin: details.start + backNode.start,
+					end: details.start + backNode.end
+				};
+				context.report({
+					data: {
+						found: backNode.raw,
+						name: backNode.resolved.name
+					},
+					fix: {
+						range,
+						text: `\\k<${backNode.resolved.name}>`
+					},
+					message: "preferNamed",
+					range
+				});
+			} });
+		} } };
+	}
+});
+//#endregion
+export { regexNamedBackreferences_default as default };
+
+//# sourceMappingURL=regexNamedBackreferences.js.map

package/lib/rules/regexNamedCaptureGroups.d.ts

@@ -0,0 +1,9 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports capturing groups in regular expressions that do not have a name.";
+    readonly id: "regexNamedCaptureGroups";
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferNamed", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexNamedCaptureGroups.d.ts.map

package/lib/rules/regexNamedCaptureGroups.js

@@ -0,0 +1,67 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { parseRegexpAst } from "./utils/parseRegexpAst.js";
+import { getRegExpConstruction } from "./utils/getRegExpConstruction.js";
+import { getRegExpLiteralDetails } from "./utils/getRegExpLiteralDetails.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexNamedCaptureGroups.ts
+var regexNamedCaptureGroups_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports capturing groups in regular expressions that do not have a name.",
+		id: "regexNamedCaptureGroups"
+	},
+	messages: { preferNamed: {
+		primary: "Anonymous capture group `{{ group }}` should be converted to a named or non-capturing group for clarity.",
+		secondary: ["Named capture groups make regex patterns more readable and maintainable.", "If the capture is not needed, use a non-capturing group `(?:...)` instead."],
+		suggestions: ["Add a name to the capture group.", "Convert to a non-capturing group."]
+	} },
+	setup(context) {
+		function checkPattern(pattern, flags, start) {
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			visitRegExpAST(regexpAst, { onCapturingGroupEnter(groupNode) {
+				if (groupNode.name) return;
+				const suggestionRange = {
+					begin: start + 1 + groupNode.start + 1,
+					end: start + 1 + groupNode.start + 1
+				};
+				context.report({
+					data: { group: groupNode.raw },
+					message: "preferNamed",
+					range: {
+						begin: start + 1 + groupNode.start,
+						end: start + 1 + groupNode.end
+					},
+					suggestions: [{
+						id: "addGroupName",
+						range: suggestionRange,
+						text: "?<name>"
+					}, {
+						id: "convertToNonCapturing",
+						range: suggestionRange,
+						text: "?:"
+					}]
+				});
+			} });
+		}
+		function checkRegexLiteral(node, services) {
+			const details = getRegExpLiteralDetails(node, services);
+			const range = getTSNodeRange(node, services.sourceFile);
+			checkPattern(details.pattern, details.flags, range.begin);
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			checkPattern(construction.raw, construction.flags, construction.start);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexNamedCaptureGroups_default as default };
+
+//# sourceMappingURL=regexNamedCaptureGroups.js.map