@flint.fyi/ts 0.15.0 → 0.18.0

package/lib/rules/regexObscureRanges.js

@@ -0,0 +1,93 @@
+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/regexObscureRanges.ts
+const alphanumericRanges = [
+	[48, 57],
+	[65, 90],
+	[97, 122]
+];
+function formatChar(char) {
+	return char.value >= 32 && char.value <= 126 ? String.fromCodePoint(char.value) : `U+${char.value.toString(16).toUpperCase().padStart(4, "0")}`;
+}
+function isControlEscape(raw) {
+	return /^\\c[A-Za-z]$/.test(raw);
+}
+function isEscapeSequence(raw) {
+	return isControlEscape(raw) || isOctalEscape(raw) || isHexLikeEscape(raw) || /^\\[nrtfvbsd]$/i.test(raw);
+}
+function isHexadecimalEscape(raw) {
+	return /^\\x[\dA-Fa-f]{2}$/.test(raw);
+}
+function isHexLikeEscape(raw) {
+	return isHexadecimalEscape(raw) || isUnicodeEscape(raw);
+}
+function isInAlphanumericRange(min, max) {
+	for (const [rangeMin, rangeMax] of alphanumericRanges) if (min >= rangeMin && max <= rangeMax) return true;
+	return false;
+}
+function isOctalEscape(raw) {
+	return /^\\[0-7]{1,3}$/.test(raw);
+}
+function isUnicodeEscape(raw) {
+	return /^\\u[\dA-Fa-f]{4}$/.test(raw) || /^\\u\{[\dA-Fa-f]+\}$/.test(raw);
+}
+var regexObscureRanges_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports obscure character ranges in regular expressions.",
+		id: "regexObscureRanges",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { obscure: {
+		primary: "Obscure character range '{{ range }}' ({{ minChar }} to {{ maxChar }}) is not obvious.",
+		secondary: ["Character ranges should be within well-known sets like a-z, A-Z, or 0-9 to avoid confusion."],
+		suggestions: ["Use explicit character classes or standard ranges instead."]
+	} },
+	setup(context) {
+		function checkPattern(pattern, patternStart, flags) {
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			visitRegExpAST(regexpAst, { onCharacterClassRangeEnter(rangeNode) {
+				const { max, min } = rangeNode;
+				if (min.value === max.value) return;
+				if (isControlEscape(min.raw) && isControlEscape(max.raw)) return;
+				if (isOctalEscape(min.raw) && isOctalEscape(max.raw)) return;
+				if ((isHexLikeEscape(min.raw) || min.value === 0) && isHexLikeEscape(max.raw)) return;
+				if (!isEscapeSequence(min.raw) && !isEscapeSequence(max.raw) && isInAlphanumericRange(min.value, max.value)) return;
+				context.report({
+					data: {
+						maxChar: formatChar(max),
+						minChar: formatChar(min),
+						range: rangeNode.raw
+					},
+					message: "obscure",
+					range: {
+						begin: patternStart + rangeNode.start,
+						end: patternStart + rangeNode.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 { regexObscureRanges_default as default };
+
+//# sourceMappingURL=regexObscureRanges.js.map

package/lib/rules/regexOctalEscapes.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports octal escape sequences in regular expressions.";
+    readonly id: "regexOctalEscapes";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unexpected", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexOctalEscapes.d.ts.map

package/lib/rules/regexOctalEscapes.js

@@ -0,0 +1,70 @@
+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/regexOctalEscapes.ts
+function countCapturingGroups(pattern) {
+	let count = 0;
+	visitRegExpAST(pattern, { onCapturingGroupEnter() {
+		count++;
+	} });
+	return count;
+}
+function isOctalEscape(raw) {
+	return /^\\[0-7]{1,3}$/.test(raw);
+}
+var regexOctalEscapes_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports octal escape sequences in regular expressions.",
+		id: "regexOctalEscapes",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { unexpected: {
+		primary: "Octal escape sequence '{{ raw }}' can be confused with backreferences.",
+		secondary: ["Octal escapes like \\1 can be mistaken for backreferences. The same sequence may be a character or a backreference depending on the number of capturing groups."],
+		suggestions: ["Use hexadecimal escape sequences (e.g., \\x07) instead of octal escapes."]
+	} },
+	setup(context) {
+		function checkPattern(pattern, patternStart, flags) {
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			const capturingGroupCount = countCapturingGroups(regexpAst);
+			visitRegExpAST(regexpAst, { onCharacterEnter(charNode) {
+				if (charNode.raw === "\\0") return;
+				if (!isOctalEscape(charNode.raw)) return;
+				const octalMatch = /^\\([0-7]+)$/.exec(charNode.raw);
+				if (octalMatch?.[1]) {
+					const octalValue = parseInt(octalMatch[1], 8);
+					if (octalValue > 0 && octalValue <= capturingGroupCount && !charNode.raw.startsWith("\\0")) return;
+				}
+				if (charNode.raw.startsWith("\\0") || !(charNode.parent.type === "CharacterClass" || charNode.parent.type === "CharacterClassRange")) context.report({
+					data: { raw: charNode.raw },
+					message: "unexpected",
+					range: {
+						begin: patternStart + charNode.start,
+						end: patternStart + charNode.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) checkPattern(construction.raw, construction.start + 1, construction.flags);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexOctalEscapes_default as default };
+
+//# sourceMappingURL=regexOctalEscapes.js.map

package/lib/rules/regexPlusQuantifiers.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports quantifiers `{1,}` in regular expressions that should use `+` instead.";
+    readonly id: "regexPlusQuantifiers";
+    readonly presets: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferPlus", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexPlusQuantifiers.d.ts.map

package/lib/rules/regexPlusQuantifiers.js

@@ -0,0 +1,68 @@
+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/regexPlusQuantifiers.ts
+function getQuantifierOffsets(quantifier) {
+	return [quantifier.element.end - quantifier.start, quantifier.greedy ? quantifier.end - quantifier.start : quantifier.end - quantifier.start - 1];
+}
+var regexPlusQuantifiers_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports quantifiers `{1,}` in regular expressions that should use `+` instead.",
+		id: "regexPlusQuantifiers",
+		presets: ["stylisticStrict"]
+	},
+	messages: { preferPlus: {
+		primary: "Prefer the more succinct `+` quantifier instead of `{{ quantifier }}`.",
+		secondary: ["The `+` quantifier is a more concise way to express matching one or more of the preceding element."],
+		suggestions: ["Replace `{{ quantifier }}` with `+`."]
+	} },
+	setup(context) {
+		function checkPattern(pattern, patternStart, flags, isStringPattern) {
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			visitRegExpAST(regexpAst, { onQuantifierEnter(quantifier) {
+				if (quantifier.min !== 1 || quantifier.max !== Infinity) return;
+				const [startOffset, endOffset] = getQuantifierOffsets(quantifier);
+				const quantifierText = quantifier.raw.slice(startOffset, endOffset);
+				if (quantifierText === "+") return;
+				const replacement = quantifier.greedy ? "+" : "+?";
+				context.report({
+					data: { quantifier: quantifierText },
+					fix: {
+						range: {
+							begin: patternStart + quantifier.start + startOffset,
+							end: patternStart + quantifier.start + (isStringPattern ? endOffset : quantifier.raw.length)
+						},
+						text: replacement
+					},
+					message: "preferPlus",
+					range: {
+						begin: patternStart + quantifier.start + startOffset,
+						end: patternStart + quantifier.start + endOffset
+					}
+				});
+			} });
+		}
+		function checkRegexLiteral(node, services) {
+			const details = getRegExpLiteralDetails(node, services);
+			checkPattern(details.pattern, details.start, details.flags, false);
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			checkPattern(construction.raw, construction.start + 1, construction.flags, true);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexPlusQuantifiers_default as default };
+
+//# sourceMappingURL=regexPlusQuantifiers.js.map

package/lib/rules/regexPredefinedAssertions.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports regex lookarounds that can be replaced with predefined assertions.";
+    readonly id: "regexPredefinedAssertions";
+    readonly presets: ["stylistic"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferPredefinedAssertion", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexPredefinedAssertions.d.ts.map

package/lib/rules/regexPredefinedAssertions.js

@@ -0,0 +1,127 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { parseRegexpAst } from "./utils/parseRegexpAst.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexPredefinedAssertions.ts
+function getPreferredAssertion(node) {
+	if (node.alternatives.length !== 1) return;
+	const elements = node.alternatives[0].elements;
+	if (elements.length !== 1) return;
+	const element = elements[0];
+	if (element.type !== "CharacterSet" || element.kind === "any" || element.kind === "digit" || element.kind === "space" || element.negate) return;
+	if (element.kind === "word") {
+		if (node.kind === "lookahead" && !node.negate) return "\\B";
+		if (node.kind === "lookahead" && node.negate) return "\\b";
+		if (node.kind === "lookbehind" && !node.negate) return "\\B";
+		if (node.kind === "lookbehind" && node.negate) return "\\b";
+	}
+}
+function isNegativeLookaheadDot(node) {
+	if (node.type !== "Assertion" || node.kind !== "lookahead" || !node.negate) return false;
+	if (node.alternatives.length !== 1) return false;
+	const elements = node.alternatives[0].elements;
+	if (elements.length !== 1) return false;
+	const element = elements[0];
+	return element.type === "CharacterSet" && element.kind === "any";
+}
+function isNegativeLookbehindDot(node) {
+	if (node.type !== "Assertion" || node.kind !== "lookbehind" || !node.negate) return false;
+	if (node.alternatives.length !== 1) return false;
+	const elements = node.alternatives[0].elements;
+	if (elements.length !== 1) return false;
+	const element = elements[0];
+	return element.type === "CharacterSet" && element.kind === "any";
+}
+var regexPredefinedAssertions_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports regex lookarounds that can be replaced with predefined assertions.",
+		id: "regexPredefinedAssertions",
+		presets: ["stylistic"]
+	},
+	messages: { preferPredefinedAssertion: {
+		primary: "Prefer the predefined assertion `{{ preferred }}` over the verbose lookaround `{{ found }}`.",
+		secondary: ["Predefined assertions are more concise and communicate intent directly."],
+		suggestions: ["Replace `{{ found }}` with `{{ preferred }}`."]
+	} },
+	setup(context) {
+		return { visitors: { RegularExpressionLiteral: (node, { sourceFile }) => {
+			const match = /^\/(.+)\/([dgimsuyv]*)$/.exec(node.text);
+			if (!match) return;
+			const [, pattern, flagsStr] = match;
+			if (!pattern) return;
+			const regexpAst = parseRegexpAst(pattern, flagsStr);
+			if (!regexpAst) return;
+			const range = getTSNodeRange(node, sourceFile);
+			if (regexpAst.alternatives.length === 1) {
+				const { elements } = regexpAst.alternatives[0];
+				if (elements.length) {
+					const first = elements[0];
+					if (isNegativeLookbehindDot(first)) context.report({
+						data: {
+							found: first.raw,
+							preferred: "^"
+						},
+						fix: {
+							range: {
+								begin: range.begin + 1 + first.start,
+								end: range.begin + 1 + first.end
+							},
+							text: "^"
+						},
+						message: "preferPredefinedAssertion",
+						range: {
+							begin: range.begin + 1 + first.start,
+							end: range.begin + 1 + first.end
+						}
+					});
+					const last = elements.at(-1);
+					if (isNegativeLookaheadDot(last)) context.report({
+						data: {
+							found: last.raw,
+							preferred: "$"
+						},
+						fix: {
+							range: {
+								begin: range.begin + 1 + last.start,
+								end: range.begin + 1 + last.end
+							},
+							text: "$"
+						},
+						message: "preferPredefinedAssertion",
+						range: {
+							begin: range.begin + 1 + last.start,
+							end: range.begin + 1 + last.end
+						}
+					});
+				}
+			}
+			visitRegExpAST(regexpAst, { onAssertionEnter(assertionNode) {
+				if (assertionNode.kind !== "lookahead" && assertionNode.kind !== "lookbehind") return;
+				const preferred = getPreferredAssertion(assertionNode);
+				if (!preferred) return;
+				context.report({
+					data: {
+						found: assertionNode.raw,
+						preferred
+					},
+					fix: {
+						range: {
+							begin: range.begin + 1 + assertionNode.start,
+							end: range.begin + 1 + assertionNode.end
+						},
+						text: preferred
+					},
+					message: "preferPredefinedAssertion",
+					range: {
+						begin: range.begin + 1 + assertionNode.start,
+						end: range.begin + 1 + assertionNode.end
+					}
+				});
+			} });
+		} } };
+	}
+});
+//#endregion
+export { regexPredefinedAssertions_default as default };
+
+//# sourceMappingURL=regexPredefinedAssertions.js.map

package/lib/rules/regexQuestionQuantifiers.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports quantifiers `{0,1}` in regular expressions that should use `?` instead.";
+    readonly id: "regexQuestionQuantifiers";
+    readonly presets: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferOptionalGroup" | "preferQuestion", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexQuestionQuantifiers.d.ts.map

package/lib/rules/regexQuestionQuantifiers.js

@@ -0,0 +1,104 @@
+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/regexQuestionQuantifiers.ts
+function getQuantifierOffsets(quantifier) {
+	return [quantifier.element.end - quantifier.start, quantifier.greedy ? quantifier.end - quantifier.start : quantifier.end - quantifier.start - 1];
+}
+function hasTrailingEmptyAlternative(group) {
+	if (group.alternatives.length < 2) return false;
+	return !group.alternatives.at(-1).elements.length;
+}
+function isGroupQuantified(group) {
+	const parent = group.parent;
+	return parent.type === "Quantifier" && parent.element === group;
+}
+var regexQuestionQuantifiers_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports quantifiers `{0,1}` in regular expressions that should use `?` instead.",
+		id: "regexQuestionQuantifiers",
+		presets: ["stylisticStrict"]
+	},
+	messages: {
+		preferOptionalGroup: {
+			primary: "Prefer optional group syntax using `?` instead of a trailing empty alternative.",
+			secondary: ["Using `(?:...)?` is clearer than using an empty alternative `(?:...|)`."],
+			suggestions: ["Remove the trailing empty alternative and add `?` quantifier."]
+		},
+		preferQuestion: {
+			primary: "Prefer the more succinct `?` quantifier instead of '{{ quantifier }}'.",
+			secondary: ["The `?` quantifier is a more concise way to express matching zero or one of the preceding element."],
+			suggestions: ["Replace '{{ quantifier }}' with `?`."]
+		}
+	},
+	setup(context) {
+		function checkPattern(pattern, patternStart, flags, isStringPattern) {
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			visitRegExpAST(regexpAst, {
+				onGroupEnter(group) {
+					if (!hasTrailingEmptyAlternative(group) || isGroupQuantified(group)) return;
+					const removeStart = group.alternatives.at(-2).end - group.start;
+					const removeEnd = group.end - group.start;
+					context.report({
+						fix: {
+							range: {
+								begin: patternStart + group.start + removeStart,
+								end: patternStart + group.start + removeEnd
+							},
+							text: ")?"
+						},
+						message: "preferOptionalGroup",
+						range: {
+							begin: patternStart + group.start,
+							end: patternStart + group.end
+						}
+					});
+				},
+				onQuantifierEnter(quantifier) {
+					if (quantifier.min !== 0 || quantifier.max !== 1) return;
+					const [startOffset, endOffset] = getQuantifierOffsets(quantifier);
+					const quantifierText = quantifier.raw.slice(startOffset, endOffset);
+					if (quantifierText === "?") return;
+					const replacement = quantifier.greedy ? "?" : "??";
+					context.report({
+						data: { quantifier: quantifierText },
+						fix: {
+							range: {
+								begin: patternStart + quantifier.start + startOffset,
+								end: patternStart + quantifier.start + (isStringPattern ? endOffset : quantifier.raw.length)
+							},
+							text: replacement
+						},
+						message: "preferQuestion",
+						range: {
+							begin: patternStart + quantifier.start + startOffset,
+							end: patternStart + quantifier.start + endOffset
+						}
+					});
+				}
+			});
+		}
+		function checkRegexLiteral(node, services) {
+			const details = getRegExpLiteralDetails(node, services);
+			checkPattern(details.pattern, details.start, details.flags, false);
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			checkPattern(construction.raw, construction.start + 1, construction.flags, true);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexQuestionQuantifiers_default as default };
+
+//# sourceMappingURL=regexQuestionQuantifiers.js.map

package/lib/rules/regexRepeatQuantifiers.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports consecutive identical elements in regular expressions that should use quantifiers.";
+    readonly id: "regexRepeatQuantifiers";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferQuantifier", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexRepeatQuantifiers.d.ts.map

package/lib/rules/regexRepeatQuantifiers.js

@@ -0,0 +1,96 @@
+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/regexRepeatQuantifiers.ts
+function getSignature(element) {
+	return element.type + ":" + element.raw;
+}
+function isFixableAtom(element) {
+	switch (element.type) {
+		case "Backreference":
+		case "CharacterClass":
+		case "CharacterSet": return true;
+		case "Character": return element.raw !== "{" && element.raw !== "}";
+		default: return false;
+	}
+}
+var regexRepeatQuantifiers_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports consecutive identical elements in regular expressions that should use quantifiers.",
+		id: "regexRepeatQuantifiers",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { preferQuantifier: {
+		primary: "Prefer `{{ replacement }}` instead of repeating `{{ atom }}` {{ count }} times.",
+		secondary: ["Using a quantifier is more concise than repeating the same element."],
+		suggestions: ["Replace with `{{ replacement }}`."]
+	} },
+	setup(context) {
+		function checkPattern(pattern, patternStart, flags) {
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			visitRegExpAST(regexpAst, { onAlternativeEnter(alternative) {
+				const elements = alternative.elements;
+				let index = 0;
+				while (index < elements.length) {
+					const element = elements[index];
+					if (!isFixableAtom(element)) {
+						index++;
+						continue;
+					}
+					const signature = getSignature(element);
+					let endIndex = index + 1;
+					while (endIndex < elements.length && isFixableAtom(elements[endIndex]) && getSignature(elements[endIndex]) === signature) endIndex++;
+					const count = endIndex - index;
+					if (count >= 5) {
+						const atomText = element.raw;
+						const replacement = atomText + "{" + String(count) + "}";
+						const runStart = element.start;
+						const runEnd = elements[endIndex - 1].end;
+						context.report({
+							data: {
+								atom: atomText,
+								count: String(count),
+								replacement
+							},
+							fix: {
+								range: {
+									begin: patternStart + runStart,
+									end: patternStart + runEnd
+								},
+								text: replacement
+							},
+							message: "preferQuantifier",
+							range: {
+								begin: patternStart + runStart,
+								end: patternStart + runEnd
+							}
+						});
+					}
+					index = endIndex;
+				}
+			} });
+		}
+		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 { regexRepeatQuantifiers_default as default };
+
+//# sourceMappingURL=regexRepeatQuantifiers.js.map

package/lib/rules/regexResultArrayGroups.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports indexed access on regex result arrays when named capturing groups should be used.";
+    readonly id: "regexResultArrayGroups";
+    readonly presets: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferGroups", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexResultArrayGroups.d.ts.map