@flint.fyi/ts 0.15.0 → 0.18.0

package/lib/rules/regexUnnecessaryReferentialBackreferences.js

@@ -0,0 +1,123 @@
+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/regexUnnecessaryReferentialBackreferences.ts
+function containsNode(ancestor, target) {
+	if (ancestor === target) return true;
+	switch (ancestor.type) {
+		case "Alternative": return ancestor.elements.some((element) => containsNode(element, target));
+		case "Assertion":
+			if (ancestor.kind === "lookahead" || ancestor.kind === "lookbehind") return ancestor.alternatives.some((alternative) => containsNode(alternative, target));
+			return false;
+		case "CapturingGroup":
+		case "Group":
+		case "Pattern": return ancestor.alternatives.some((alternative) => containsNode(alternative, target));
+		case "Quantifier": return containsNode(ancestor.element, target);
+		default: return false;
+	}
+}
+function getAncestors(node) {
+	const ancestors = [];
+	let current = node.parent;
+	while (current) {
+		ancestors.push(current);
+		current = current.parent;
+	}
+	return ancestors;
+}
+function groupCanOnlyMatchEmpty(group) {
+	return group.alternatives.every((alternative) => alternative.elements.every((element) => {
+		if (element.type === "Quantifier" && element.min === 0) return true;
+		if (element.type === "Group" || element.type === "CapturingGroup") return groupCanOnlyMatchEmpty(element);
+		if (element.type === "Assertion") return true;
+		return false;
+	}));
+}
+function isBackreferenceAfterGroup(group, backreference) {
+	const groupAncestors = getAncestors(group);
+	const backrefAncestors = getAncestors(backreference);
+	const commonAncestor = groupAncestors.find((ancestor) => backrefAncestors.includes(ancestor));
+	if (commonAncestor?.type !== "Alternative") return false;
+	return commonAncestor.elements.findIndex((element) => containsNode(element, group) || element === group) < commonAncestor.elements.findIndex((element) => containsNode(element, backreference) || element === backreference);
+}
+function isInsideLookahead(group) {
+	for (const ancestor of getAncestors(group)) if (ancestor.type === "Assertion" && ancestor.kind === "lookahead") return true;
+	return false;
+}
+function mayBeUndefinedAtBackref(group) {
+	const groupAncestors = getAncestors(group);
+	for (const ancestor of groupAncestors) {
+		if (ancestor.type === "Quantifier" && ancestor.min === 0) return true;
+		if (ancestor.type === "Alternative") {
+			const parent = ancestor.parent;
+			if (parent.type === "Group" || parent.type === "CapturingGroup" || parent.type === "Pattern") {
+				if (parent.alternatives.filter((alternative) => containsNode(alternative, group)).length < parent.alternatives.length) return true;
+			}
+		}
+		if (ancestor.type === "Quantifier" && ancestor.max > 1) {
+			const quantifiedElement = ancestor.element;
+			if (quantifiedElement.type === "Group" || quantifiedElement.type === "CapturingGroup") {
+				if (quantifiedElement === group) continue;
+				if (quantifiedElement.alternatives.filter((alternative) => containsNode(alternative, group)).length < quantifiedElement.alternatives.length) return true;
+			}
+		}
+	}
+	return false;
+}
+var regexUnnecessaryReferentialBackreferences_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports backreferences that may reference a capturing group that was not matched.",
+		id: "regexUnnecessaryReferentialBackreferences",
+		presets: ["logical"]
+	},
+	messages: { potentiallyUselessBackref: {
+		primary: "Ensure capturing group is always matched before backreference `{{ raw }}`.",
+		secondary: ["This backreference may always be empty because the referenced capturing group might not participate in the match.", "The group may be in an optional quantifier, inside an alternation where some branches don't include it, or reset in a loop."],
+		suggestions: ["Make sure the capturing group is always matched before the backreference.", "Consider restructuring the regex to ensure the group participates in the match."]
+	} },
+	setup(context) {
+		function checkPattern(pattern, patternStart, flags) {
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			visitRegExpAST(regexpAst, { onBackreferenceEnter(backreference) {
+				const { resolved } = backreference;
+				const groups = Array.isArray(resolved) ? resolved : [resolved];
+				for (const group of groups) {
+					if (groupCanOnlyMatchEmpty(group) || isInsideLookahead(group) || !isBackreferenceAfterGroup(group, backreference)) continue;
+					if (mayBeUndefinedAtBackref(group)) {
+						context.report({
+							data: { raw: backreference.raw },
+							message: "potentiallyUselessBackref",
+							range: {
+								begin: patternStart + backreference.start,
+								end: patternStart + backreference.end
+							}
+						});
+						return;
+					}
+				}
+			} });
+		}
+		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 { regexUnnecessaryReferentialBackreferences_default as default };
+
+//# sourceMappingURL=regexUnnecessaryReferentialBackreferences.js.map

package/lib/rules/regexUnnecessarySetOperands.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports unnecessary operands in regular expression character class set operations.";
+    readonly id: "regexUnnecessarySetOperands";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "intersectionDisjoint" | "intersectionSubset" | "subtractionDisjoint" | "subtractionSubset", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexUnnecessarySetOperands.d.ts.map

package/lib/rules/regexUnnecessarySetOperands.js

@@ -0,0 +1,136 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getRegExpConstruction } from "./utils/getRegExpConstruction.js";
+import { getRegExpLiteralDetails } from "./utils/getRegExpLiteralDetails.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import { RegExpParser, visitRegExpAST } from "@eslint-community/regexpp";
+import { toUnicodeSet } from "regexp-ast-analysis";
+//#region src/rules/regexUnnecessarySetOperands.ts
+var regexUnnecessarySetOperands_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports unnecessary operands in regular expression character class set operations.",
+		id: "regexUnnecessarySetOperands",
+		presets: ["logical"]
+	},
+	messages: {
+		intersectionDisjoint: {
+			primary: "This operation can be simplified: '{{ left }}' and '{{ right }}' are disjoint, so the result is always empty.",
+			secondary: ["When two sets have no common elements, their intersection is empty.", "This likely indicates a mistake in the regular expression."],
+			suggestions: ["Review the operands to ensure they share common elements.", "Remove the expression if the empty result is intentional."]
+		},
+		intersectionSubset: {
+			primary: "This operation can be simplified: '{{ subset }}' is a subset of '{{ superset }}', so the superset operand is redundant.",
+			secondary: ["When one operand is a subset of another in an intersection, the superset is redundant.", "The result is equivalent to just the subset operand."],
+			suggestions: ["Remove the redundant superset operand."]
+		},
+		subtractionDisjoint: {
+			primary: "This operation can be simplified: '{{ left }}' and '{{ right }}' are disjoint, so the subtraction has no effect.",
+			secondary: ["Subtracting a set that shares no elements with the left operand does nothing.", "The right operand can be safely removed."],
+			suggestions: ["Remove the unnecessary right operand.", "Review the operands to ensure the subtraction is meaningful."]
+		},
+		subtractionSubset: {
+			primary: "This operation can be simplified: '{{ left }}' is a subset of '{{ right }}', so the result is always empty.",
+			secondary: ["When you subtract a set that contains all elements of the left operand, the result is empty.", "This likely indicates a mistake in the regular expression."],
+			suggestions: ["Review the operands to ensure this is intentional.", "Consider using a different pattern if the empty result is unintended."]
+		}
+	},
+	setup(context) {
+		const unicodeSetsFlags = {
+			unicode: false,
+			unicodeSets: true
+		};
+		function unwrapBrackets(raw) {
+			if (raw.startsWith("[") && raw.endsWith("]")) return raw.slice(1, -1);
+			return raw;
+		}
+		function report(node, patternStart, canFix, message, data, fixText) {
+			const range = {
+				begin: patternStart + node.start,
+				end: patternStart + node.end
+			};
+			context.report({
+				data,
+				fix: canFix && fixText ? {
+					range,
+					text: fixText
+				} : void 0,
+				message,
+				range
+			});
+		}
+		function checkIntersection(node, patternStart, canFix) {
+			const leftSet = toUnicodeSet(node.left, unicodeSetsFlags);
+			const rightSet = toUnicodeSet(node.right, unicodeSetsFlags);
+			if (leftSet.isDisjointWith(rightSet)) {
+				report(node, patternStart, canFix, "intersectionDisjoint", {
+					left: node.left.raw,
+					right: node.right.raw
+				}, "^^");
+				return;
+			}
+			if (leftSet.isSubsetOf(rightSet)) {
+				report(node, patternStart, canFix, "intersectionSubset", {
+					subset: node.left.raw,
+					superset: node.right.raw
+				}, unwrapBrackets(node.left.raw));
+				return;
+			}
+			if (rightSet.isSubsetOf(leftSet)) report(node, patternStart, canFix, "intersectionSubset", {
+				subset: node.right.raw,
+				superset: node.left.raw
+			}, unwrapBrackets(node.right.raw));
+		}
+		function checkSubtraction(node, patternStart, canFix) {
+			const leftSet = toUnicodeSet(node.left, unicodeSetsFlags);
+			const rightSet = toUnicodeSet(node.right, unicodeSetsFlags);
+			if (leftSet.isDisjointWith(rightSet)) {
+				report(node, patternStart, canFix, "subtractionDisjoint", {
+					left: node.left.raw,
+					right: node.right.raw
+				}, unwrapBrackets(node.left.raw));
+				return;
+			}
+			if (leftSet.isSubsetOf(rightSet)) report(node, patternStart, canFix, "subtractionSubset", {
+				left: node.left.raw,
+				right: node.right.raw
+			}, "^^");
+		}
+		function checkPattern(pattern, patternStart, canFix) {
+			let regexpAst;
+			try {
+				regexpAst = new RegExpParser().parsePattern(pattern, void 0, void 0, {
+					unicode: false,
+					unicodeSets: true
+				});
+			} catch {
+				return;
+			}
+			visitRegExpAST(regexpAst, {
+				onClassIntersectionEnter(node) {
+					checkIntersection(node, patternStart, canFix);
+				},
+				onClassSubtractionEnter(node) {
+					checkSubtraction(node, patternStart, canFix);
+				}
+			});
+		}
+		function checkRegexLiteral(node, services) {
+			const details = getRegExpLiteralDetails(node, services);
+			if (!details.flags.includes("v")) return;
+			checkPattern(details.pattern, details.start, true);
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction?.flags.includes("v")) return;
+			checkPattern(construction.raw, construction.start + 1, false);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexUnnecessarySetOperands_default as default };
+
+//# sourceMappingURL=regexUnnecessarySetOperands.js.map

package/lib/rules/regexUnusedCapturingGroups.d.ts

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

package/lib/rules/regexUnusedCapturingGroups.js

@@ -0,0 +1,69 @@
+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/regexUnusedCapturingGroups.ts
+function findUnusedCapturingGroups(pattern, flags) {
+	const results = [];
+	const ast = parseRegexpAst(pattern, flags);
+	if (!ast) return results;
+	visitRegExpAST(ast, { onCapturingGroupEnter(node) {
+		if (!node.references.length) results.push(node);
+	} });
+	return results;
+}
+var regexUnusedCapturingGroups_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports capturing groups in regular expressions that are never referenced.",
+		id: "regexUnusedCapturingGroups",
+		presets: ["logical"]
+	},
+	messages: { unusedCapture: {
+		primary: "Capturing group `{{ raw }}` is never referenced.",
+		secondary: ["Capturing groups that are never backreferenced can be misleading by unintentionally indicating that the group should be captured.", "Non-capturing groups are generally preferred for clarity when the group does not need to be captured."],
+		suggestions: ["Convert to a non-capturing group if the capture is not needed.", "Add a backreference if the capture is needed."]
+	} },
+	setup(context) {
+		function checkPattern(pattern, flags, start) {
+			const unusedGroups = findUnusedCapturingGroups(pattern, flags);
+			for (const group of unusedGroups) {
+				const range = {
+					begin: start + 1 + group.start,
+					end: start + 1 + group.end
+				};
+				const nonCapturing = `(?:${group.alternatives.map((alt) => alt.raw).join("|")})`;
+				context.report({
+					data: { raw: group.raw },
+					message: "unusedCapture",
+					range,
+					suggestions: [{
+						id: "useNonCapturing",
+						range,
+						text: nonCapturing
+					}]
+				});
+			}
+		}
+		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 { regexUnusedCapturingGroups_default as default };
+
+//# sourceMappingURL=regexUnusedCapturingGroups.js.map

package/lib/rules/regexUnusedFlags.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports regular expression flags that have no effect on the pattern.";
+    readonly id: "regexUnusedFlags";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unusedDotAll" | "unusedIgnoreCase" | "unusedMultiline", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexUnusedFlags.d.ts.map

package/lib/rules/regexUnusedFlags.js

@@ -0,0 +1,116 @@
+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 * as ts$1 from "typescript";
+import { visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexUnusedFlags.ts
+function analyzePattern(pattern) {
+	const usage = {
+		hasAnchor: false,
+		hasDot: false,
+		hasLetter: false
+	};
+	visitRegExpAST(pattern, {
+		onAssertionEnter(node) {
+			if (node.kind === "start" || node.kind === "end") usage.hasAnchor = true;
+		},
+		onCharacterClassRangeEnter(node) {
+			if (rangeContainsLetter(node.min.value, node.max.value)) usage.hasLetter = true;
+		},
+		onCharacterEnter(node) {
+			if (isAsciiLetter(node.value)) usage.hasLetter = true;
+		},
+		onCharacterSetEnter(node) {
+			if (node.kind === "any") usage.hasDot = true;
+		}
+	});
+	return usage;
+}
+function findUnusedFlags(pattern, flags) {
+	const regexpAst = parseRegexpAst(pattern, flags);
+	if (!regexpAst) return [];
+	const usage = analyzePattern(regexpAst);
+	const unusedFlags = [];
+	if (flags.includes("i") && !usage.hasLetter) unusedFlags.push("i");
+	if (flags.includes("m") && !usage.hasAnchor) unusedFlags.push("m");
+	if (flags.includes("s") && !usage.hasDot) unusedFlags.push("s");
+	return unusedFlags;
+}
+function isAsciiLetter(codePoint) {
+	return codePoint >= 65 && codePoint <= 90 || codePoint >= 97 && codePoint <= 122;
+}
+function rangeContainsLetter(min, max) {
+	return min <= 90 && max >= 65 || min <= 122 && max >= 97;
+}
+var regexUnusedFlags_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports regular expression flags that have no effect on the pattern.",
+		id: "regexUnusedFlags",
+		presets: ["logical"]
+	},
+	messages: {
+		unusedDotAll: {
+			primary: "The `s` flag has no effect because the pattern contains no dots.",
+			secondary: ["The dotAll flag only affects the . metacharacter."],
+			suggestions: ["Remove the 's' flag."]
+		},
+		unusedIgnoreCase: {
+			primary: "The `i` flag has no effect because the pattern contains no letters.",
+			secondary: ["The ignoreCase flag only affects matching of ASCII letters (A-Za-z)."],
+			suggestions: ["Remove the 'i' flag."]
+		},
+		unusedMultiline: {
+			primary: "The `m` flag has no effect because the pattern contains no line anchors.",
+			secondary: ["The multiline flag only affects the ^ and $ anchors."],
+			suggestions: ["Remove the 'm' flag."]
+		}
+	},
+	setup(context) {
+		function reportUnusedFlags(unusedFlags, flags, flagsStart) {
+			for (const flag of unusedFlags) {
+				const flagIndex = flags.indexOf(flag);
+				const message = flag === "i" ? "unusedIgnoreCase" : flag === "m" ? "unusedMultiline" : "unusedDotAll";
+				const range = {
+					begin: flagsStart + flagIndex,
+					end: flagsStart + flagIndex + 1
+				};
+				context.report({
+					fix: {
+						range,
+						text: ""
+					},
+					message,
+					range
+				});
+			}
+		}
+		function checkRegexLiteral(node, services) {
+			const details = getRegExpLiteralDetails(node, services);
+			const unusedFlags = findUnusedFlags(details.pattern, details.flags);
+			if (!unusedFlags.length) return;
+			const flagsStart = details.start + node.text.length - details.flags.length - 1;
+			reportUnusedFlags(unusedFlags, details.flags, flagsStart);
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction || construction.args.length < 2) return;
+			const unusedFlags = findUnusedFlags(construction.raw, construction.flags);
+			if (!unusedFlags.length) return;
+			const secondArgument = construction.args[1];
+			if (secondArgument.kind !== ts$1.SyntaxKind.StringLiteral) return;
+			const flagsStart = secondArgument.getStart(services.sourceFile) + 1;
+			reportUnusedFlags(unusedFlags, construction.flags, flagsStart);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexUnusedFlags_default as default };
+
+//# sourceMappingURL=regexUnusedFlags.js.map

package/lib/rules/regexUnusedLazyQuantifiers.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports lazy quantifiers that have no effect because the quantifier is constant.";
+    readonly id: "regexUnusedLazyQuantifiers";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "uselessLazy", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexUnusedLazyQuantifiers.d.ts.map

package/lib/rules/regexUnusedLazyQuantifiers.js

@@ -0,0 +1,63 @@
+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/regexUnusedLazyQuantifiers.ts
+var regexUnusedLazyQuantifiers_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports lazy quantifiers that have no effect because the quantifier is constant.",
+		id: "regexUnusedLazyQuantifiers",
+		presets: ["logical"]
+	},
+	messages: { uselessLazy: {
+		primary: "Lazy quantifier `{{ raw }}` has no effect because the quantifier matches exactly {{ count }} time(s).",
+		secondary: ["When a quantifier has fixed bounds (min equals max), there is no choice in how many times to match, so lazy vs greedy is irrelevant."],
+		suggestions: ["Remove the '?' to use the greedy form."]
+	} },
+	setup(context) {
+		function checkPattern(pattern, patternStart, flags) {
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			visitRegExpAST(regexpAst, { onQuantifierEnter(node) {
+				if (!node.greedy && node.min === node.max) {
+					const range = {
+						begin: patternStart + node.start,
+						end: patternStart + node.end
+					};
+					context.report({
+						data: {
+							count: node.min,
+							raw: node.raw
+						},
+						fix: {
+							range,
+							text: node.raw.slice(0, -1)
+						},
+						message: "uselessLazy",
+						range
+					});
+				}
+			} });
+		}
+		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.pattern, construction.start + 1, construction.flags);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexUnusedLazyQuantifiers_default as default };
+
+//# sourceMappingURL=regexUnusedLazyQuantifiers.js.map

package/lib/rules/regexUnusedQuantifiers.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports quantifiers that match exactly once, making them unnecessary.";
+    readonly id: "regexUnusedQuantifiers";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "uselessQuantifier", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexUnusedQuantifiers.d.ts.map

package/lib/rules/regexUnusedQuantifiers.js

@@ -0,0 +1,63 @@
+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/regexUnusedQuantifiers.ts
+var regexUnusedQuantifiers_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports quantifiers that match exactly once, making them unnecessary.",
+		id: "regexUnusedQuantifiers",
+		presets: ["logical"]
+	},
+	messages: { uselessQuantifier: {
+		primary: "Quantifier `{{ raw }}` is unnecessary because it matches exactly once.",
+		secondary: ["A quantifier that matches exactly once can be removed without changing the pattern's behavior."],
+		suggestions: ["Remove the quantifier if one match is all that is needed.", "Change the quantifier if multiple matches are intended."]
+	} },
+	setup(context) {
+		function checkPattern(pattern, patternStart, flags) {
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			visitRegExpAST(regexpAst, { onQuantifierEnter(node) {
+				if (node.min === 1 && node.max === 1) {
+					const quantifierStart = node.element.end;
+					context.report({
+						data: { raw: node.raw },
+						fix: {
+							range: {
+								begin: patternStart + quantifierStart,
+								end: patternStart + node.end
+							},
+							text: ""
+						},
+						message: "uselessQuantifier",
+						range: {
+							begin: patternStart + node.start,
+							end: patternStart + node.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.pattern, construction.start + 1, construction.flags);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexUnusedQuantifiers_default as default };
+
+//# sourceMappingURL=regexUnusedQuantifiers.js.map

package/lib/rules/regexValidity.d.ts

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