@flint.fyi/ts 0.20.0 → 0.22.0

package/lib/rules/regexObscureRanges.js

@@ -1,93 +0,0 @@
-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

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

package/lib/rules/regexOctalEscapes.js

@@ -1,70 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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: readonly ["stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferPlus", undefined>;
-export default _default;
-//# sourceMappingURL=regexPlusQuantifiers.d.ts.map

package/lib/rules/regexPlusQuantifiers.js

@@ -1,68 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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: readonly ["stylistic"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferPredefinedAssertion", undefined>;
-export default _default;
-//# sourceMappingURL=regexPredefinedAssertions.d.ts.map

package/lib/rules/regexPredefinedAssertions.js

@@ -1,127 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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: readonly ["stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferOptionalGroup" | "preferQuestion", undefined>;
-export default _default;
-//# sourceMappingURL=regexQuestionQuantifiers.d.ts.map

package/lib/rules/regexQuestionQuantifiers.js

@@ -1,104 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferQuantifier", undefined>;
-export default _default;
-//# sourceMappingURL=regexRepeatQuantifiers.d.ts.map

package/lib/rules/regexRepeatQuantifiers.js

@@ -1,96 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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: readonly ["stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferGroups", undefined>;
-export default _default;
-//# sourceMappingURL=regexResultArrayGroups.d.ts.map