@flint.fyi/ts 0.14.6 → 0.18.0

package/lib/rules/regexEmptyCapturingGroups.d.ts

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

package/lib/rules/regexEmptyCapturingGroups.js

@@ -0,0 +1,67 @@
+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 { parseRegExpLiteral, visitRegExpAST } from "@eslint-community/regexpp";
+import { isZeroLength } from "regexp-ast-analysis";
+//#region src/rules/regexEmptyCapturingGroups.ts
+function findEmptyCapturingGroups(pattern, flags) {
+	const results = [];
+	let ast;
+	try {
+		ast = parseRegExpLiteral(new RegExp(pattern, flags));
+	} catch {
+		return results;
+	}
+	visitRegExpAST(ast, { onCapturingGroupEnter(node) {
+		if (node.name) return;
+		if (isZeroLength(node, ast.flags)) results.push(node);
+	} });
+	return results;
+}
+var regexEmptyCapturingGroups_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports capturing groups that only capture empty strings.",
+		id: "regexEmptyCapturingGroups",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { emptyCapture: {
+		primary: "This capturing group captures only empty strings.",
+		secondary: ["This capturing group will only ever match zero-length text.", "It may indicate a mistake in the pattern."],
+		suggestions: ["Add content to the capturing group.", "Convert the capturing group to a non-capturing group."]
+	} },
+	setup(context) {
+		function checkRegexLiteral(node, services) {
+			const { flags, pattern, start } = getRegExpLiteralDetails(node, services);
+			const emptyGroups = findEmptyCapturingGroups(pattern, flags);
+			for (const group of emptyGroups) context.report({
+				message: "emptyCapture",
+				range: {
+					begin: start + group.start - 1,
+					end: start + group.end - 1
+				}
+			});
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			const emptyGroups = findEmptyCapturingGroups(construction.pattern.replace(/\\\\/g, "\\"), construction.flags);
+			for (const group of emptyGroups) context.report({
+				message: "emptyCapture",
+				range: {
+					begin: construction.start + group.start,
+					end: construction.start + group.end
+				}
+			});
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexEmptyCapturingGroups_default as default };
+
+//# sourceMappingURL=regexEmptyCapturingGroups.js.map

package/lib/rules/regexEmptyCharacterClasses.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports character classes that match no characters.";
+    readonly id: "regexEmptyCharacterClasses";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "empty", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexEmptyCharacterClasses.d.ts.map

package/lib/rules/regexEmptyCharacterClasses.js

@@ -0,0 +1,68 @@
+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 { parseRegExpLiteral, visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexEmptyCharacterClasses.ts
+function characterClassIsEmpty(node) {
+	return !node.negate && !node.elements.length;
+}
+function findEmptyCharacterClasses(pattern, flags) {
+	const results = [];
+	let ast;
+	try {
+		ast = parseRegExpLiteral(new RegExp(pattern, flags));
+	} catch {
+		return results;
+	}
+	visitRegExpAST(ast, { onCharacterClassEnter(node) {
+		if (characterClassIsEmpty(node)) results.push(node);
+	} });
+	return results;
+}
+var regexEmptyCharacterClasses_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports character classes that match no characters.",
+		id: "regexEmptyCharacterClasses",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { empty: {
+		primary: "This character class matches no characters because it is empty.",
+		secondary: ["An empty character class `[]` never matches anything.", "This often indicates a mistake in the regular expression."],
+		suggestions: ["Add characters to the class if it's meant to capture any.", "Remove the class if it is unintended."]
+	} },
+	setup(context) {
+		function checkRegexLiteral(node, services) {
+			const { flags, pattern, start } = getRegExpLiteralDetails(node, services);
+			const emptyClasses = findEmptyCharacterClasses(pattern, flags);
+			for (const charClass of emptyClasses) context.report({
+				message: "empty",
+				range: {
+					begin: start + charClass.start - 1,
+					end: start + charClass.end - 1
+				}
+			});
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			const emptyClasses = findEmptyCharacterClasses(construction.pattern.replace(/\\\\/g, "\\"), construction.flags);
+			for (const charClass of emptyClasses) context.report({
+				message: "empty",
+				range: {
+					begin: construction.start + charClass.start,
+					end: construction.start + charClass.end
+				}
+			});
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexEmptyCharacterClasses_default as default };
+
+//# sourceMappingURL=regexEmptyCharacterClasses.js.map

package/lib/rules/regexEmptyGroups.d.ts

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

package/lib/rules/regexEmptyGroups.js

@@ -0,0 +1,66 @@
+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/regexEmptyGroups.ts
+function isEmptyGroup(group) {
+	return group.alternatives.every((alternative) => !alternative.elements.length);
+}
+var regexEmptyGroups_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports empty groups in regular expressions.",
+		id: "regexEmptyGroups",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { emptyGroup: {
+		primary: "Empty {{ kind }} `{{ raw }}` matches nothing.",
+		secondary: ["Empty groups match the empty string and have no effect on the regex."],
+		suggestions: ["Remove the empty group.", "Replace the empty group with a non-capturing group."]
+	} },
+	setup(context) {
+		function reportEmptyGroup(group, kind, start) {
+			if (isEmptyGroup(group)) context.report({
+				data: {
+					kind,
+					raw: group.raw
+				},
+				message: "emptyGroup",
+				range: {
+					begin: start + group.start,
+					end: start + group.end
+				}
+			});
+		}
+		function checkPattern(pattern, patternStart, flags) {
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			visitRegExpAST(regexpAst, {
+				onCapturingGroupEnter(group) {
+					reportEmptyGroup(group, "capturing group", patternStart);
+				},
+				onGroupEnter(group) {
+					reportEmptyGroup(group, "non-capturing group", patternStart);
+				}
+			});
+		}
+		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.pattern, construction.start + 1, construction.flags);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexEmptyGroups_default as default };
+
+//# sourceMappingURL=regexEmptyGroups.js.map

package/lib/rules/regexEmptyLazyQuantifiers.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports lazy quantifiers at the end of regular expressions.";
+    readonly id: "regexEmptyLazyQuantifiers";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "uselessElement" | "uselessQuantifier" | "uselessRange", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexEmptyLazyQuantifiers.d.ts.map

package/lib/rules/regexEmptyLazyQuantifiers.js

@@ -0,0 +1,92 @@
+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/regexEmptyLazyQuantifiers.ts
+function* extractLazyEndQuantifiers(alternatives) {
+	for (const { elements } of alternatives) {
+		if (!elements.length) continue;
+		const last = elements.at(-1);
+		if (!last) continue;
+		switch (last.type) {
+			case "CapturingGroup":
+			case "Group":
+				yield* extractLazyEndQuantifiers(last.alternatives);
+				break;
+			case "Quantifier":
+				if (!last.greedy && last.min !== last.max) yield last;
+				else if (last.max === 1) {
+					const element = last.element;
+					if (element.type === "Group" || element.type === "CapturingGroup") yield* extractLazyEndQuantifiers(element.alternatives);
+				}
+				break;
+			default: break;
+		}
+	}
+}
+var regexEmptyLazyQuantifiers_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports lazy quantifiers at the end of regular expressions.",
+		id: "regexEmptyLazyQuantifiers",
+		presets: ["logical"]
+	},
+	messages: {
+		uselessElement: {
+			primary: "Lazy quantifier '{{ raw }}' at end of pattern will only match the empty string.",
+			secondary: ["Lazy quantifiers at the end of a pattern with minimum 0 will match nothing because there's nothing after them to satisfy."],
+			suggestions: ["Remove the lazy quantifier.", "Add characters after the lazy quantifier to make it useful."]
+		},
+		uselessQuantifier: {
+			primary: "Lazy quantifier '{{ raw }}' at end of pattern will always match exactly once.",
+			secondary: ["Lazy quantifiers at the end of a pattern with minimum 1 will match exactly once because there's nothing after them to satisfy."],
+			suggestions: ["Remove the lazy quantifier.", "Add characters after the lazy quantifier to make it useful."]
+		},
+		uselessRange: {
+			primary: "Lazy quantifier '{{ raw }}' at end of pattern will always match exactly {{ min }} times.",
+			secondary: ["Lazy quantifiers at the end of a pattern will match only their minimum because there's nothing after them to satisfy."],
+			suggestions: ["Remove the lazy quantifier.", "Add characters after the lazy quantifier to make it useful."]
+		}
+	},
+	setup(context) {
+		function checkPattern(pattern, patternStart, flags) {
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			visitRegExpAST(regexpAst, { onPatternEnter(patternNode) {
+				for (const lazy of extractLazyEndQuantifiers(patternNode.alternatives)) {
+					const messageId = lazy.min === 0 ? "uselessElement" : lazy.min === 1 ? "uselessQuantifier" : "uselessRange";
+					context.report({
+						data: {
+							min: lazy.min,
+							raw: lazy.raw
+						},
+						message: messageId,
+						range: {
+							begin: patternStart + lazy.start,
+							end: patternStart + lazy.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 { regexEmptyLazyQuantifiers_default as default };
+
+//# sourceMappingURL=regexEmptyLazyQuantifiers.js.map

package/lib/rules/regexEmptyLookaroundsAssertions.d.ts

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

package/lib/rules/regexEmptyLookaroundsAssertions.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";
+import { isPotentiallyEmpty } from "regexp-ast-analysis";
+//#region src/rules/regexEmptyLookaroundsAssertions.ts
+var regexEmptyLookaroundsAssertions_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports empty lookahead and lookbehind assertions in regular expressions.",
+		id: "regexEmptyLookaroundsAssertions",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { emptyLookaround: {
+		primary: "Empty {{ kind }} will trivially {{ result }} all inputs.",
+		secondary: ["Empty lookaround assertions match the empty string and will always succeed (or fail if negated) without checking anything meaningful."],
+		suggestions: []
+	} },
+	setup(context) {
+		function checkPattern(pattern, patternStart, flagsText) {
+			const regexpAst = parseRegexpAst(pattern, flagsText);
+			if (!regexpAst) return;
+			const flags = {
+				dotAll: flagsText.includes("s"),
+				global: flagsText.includes("g"),
+				hasIndices: flagsText.includes("d"),
+				ignoreCase: flagsText.includes("i"),
+				multiline: flagsText.includes("m"),
+				sticky: flagsText.includes("y"),
+				unicode: flagsText.includes("u"),
+				unicodeSets: flagsText.includes("v")
+			};
+			visitRegExpAST(regexpAst, { onAssertionEnter(assertion) {
+				if (assertion.kind !== "lookahead" && assertion.kind !== "lookbehind") return;
+				if (isPotentiallyEmpty(assertion.alternatives, flags)) context.report({
+					data: {
+						kind: assertion.kind,
+						result: assertion.negate ? "reject" : "accept"
+					},
+					message: "emptyLookaround",
+					range: {
+						begin: patternStart + assertion.start,
+						end: patternStart + assertion.end
+					}
+				});
+			} });
+		}
+		function checkRegexLiteral(node, services) {
+			const { flags, pattern, start } = getRegExpLiteralDetails(node, services);
+			checkPattern(pattern, start, flags);
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			checkPattern(construction.pattern.replace(/\\\\/g, "\\"), construction.start + 1, construction.flags);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexEmptyLookaroundsAssertions_default as default };
+
+//# sourceMappingURL=regexEmptyLookaroundsAssertions.js.map

package/lib/rules/regexEmptyStringLiterals.d.ts

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

package/lib/rules/regexEmptyStringLiterals.js

@@ -0,0 +1,66 @@
+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 { parseRegExpLiteral, visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexEmptyStringLiterals.ts
+function findEmptyStringLiterals(pattern, flags) {
+	const results = [];
+	if (!flags.includes("v")) return results;
+	let ast;
+	try {
+		ast = parseRegExpLiteral(new RegExp(pattern, flags));
+	} catch {
+		return results;
+	}
+	visitRegExpAST(ast, { onClassStringDisjunctionEnter(node) {
+		if (node.alternatives.every((alternative) => !alternative.elements.length)) results.push(node);
+	} });
+	return results;
+}
+var regexEmptyStringLiterals_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports empty string literals in character classes.",
+		id: "regexEmptyStringLiterals",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { emptyStringLiteral: {
+		primary: "This empty string literal in a character class will always match the empty string.",
+		secondary: ["The `\\q{}` string literal matches the empty string.", "This generally either does not benefit the regular expression or can cause unintended matches."],
+		suggestions: ["Remove the empty string literal if this was unintentional.", "Use a quantifier on the character class if this was intentional."]
+	} },
+	setup(context) {
+		function checkRegexLiteral(node, services) {
+			const { flags, pattern, start } = getRegExpLiteralDetails(node, services);
+			const emptyLiterals = findEmptyStringLiterals(pattern, flags);
+			for (const literal of emptyLiterals) context.report({
+				message: "emptyStringLiteral",
+				range: {
+					begin: start + literal.start - 1,
+					end: start + literal.end - 1
+				}
+			});
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			const emptyLiterals = findEmptyStringLiterals(construction.pattern.replace(/\\\\/g, "\\"), construction.flags);
+			for (const literal of emptyLiterals) context.report({
+				message: "emptyStringLiteral",
+				range: {
+					begin: construction.start + literal.start,
+					end: construction.start + literal.end
+				}
+			});
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexEmptyStringLiterals_default as default };
+
+//# sourceMappingURL=regexEmptyStringLiterals.js.map

package/lib/rules/regexEscapeBackspaces.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports escape backspace (`[\\b]`) in character classes.";
+    readonly id: "regexEscapeBackspaces";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "escapeBackspace", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexEscapeBackspaces.d.ts.map

package/lib/rules/regexEscapeBackspaces.js

@@ -0,0 +1,69 @@
+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 { parseRegExpLiteral, visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexEscapeBackspaces.ts
+function findEscapeBackspaces(pattern, flags) {
+	const results = [];
+	let ast;
+	try {
+		ast = parseRegExpLiteral(new RegExp(pattern, flags));
+	} catch {
+		return results;
+	}
+	visitRegExpAST(ast, { onCharacterEnter(node) {
+		if (node.raw === "\\b") results.push(node);
+	} });
+	return results;
+}
+var regexEscapeBackspaces_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports escape backspace (`[\\b]`) in character classes.",
+		id: "regexEscapeBackspaces",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { escapeBackspace: {
+		primary: "Prefer the clearer `\\u0008` instead of `[\\b]` for backspace character.",
+		secondary: [
+			"The `\\b` inside a character class matches the backspace character (U+0008).",
+			"Outside a character class, `\\b` is a word boundary assertion.",
+			"Using `\\u0008` makes the intent clearer."
+		],
+		suggestions: ["Replace `\\b` with `\\u0008`."]
+	} },
+	setup(context) {
+		function checkRegexLiteral(node, services) {
+			const { flags, pattern, start } = getRegExpLiteralDetails(node, services);
+			const backspaces = findEscapeBackspaces(pattern, flags);
+			for (const backspace of backspaces) context.report({
+				message: "escapeBackspace",
+				range: {
+					begin: start + backspace.start - 1,
+					end: start + backspace.end - 1
+				}
+			});
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			const backspaces = findEscapeBackspaces(construction.pattern.replace(/\\\\/g, "\\"), construction.flags);
+			for (const backspace of backspaces) context.report({
+				message: "escapeBackspace",
+				range: {
+					begin: construction.start + backspace.start,
+					end: construction.start + backspace.end
+				}
+			});
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexEscapeBackspaces_default as default };
+
+//# sourceMappingURL=regexEscapeBackspaces.js.map

package/lib/rules/regexExecutors.d.ts

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

package/lib/rules/regexExecutors.js

@@ -0,0 +1,58 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+//#region src/rules/regexExecutors.ts
+function getRegexFlags(node, sourceFile) {
+	switch (node.kind) {
+		case ts.SyntaxKind.CallExpression:
+		case ts.SyntaxKind.NewExpression:
+			if (ts.isIdentifier(node.expression) && node.expression.text === "RegExp" && node.arguments) {
+				if (node.arguments.length < 2) return "";
+				const flagsArg = node.arguments[1];
+				if (ts.isStringLiteral(flagsArg)) return flagsArg.text;
+			}
+			return;
+		case ts.SyntaxKind.RegularExpressionLiteral: {
+			const text = node.getText(sourceFile);
+			const lastSlash = text.lastIndexOf("/");
+			return lastSlash >= 0 ? text.slice(lastSlash + 1) : "";
+		}
+		default: return;
+	}
+}
+var regexExecutors_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports String.prototype.match calls that can be replaced with RegExp.prototype.exec.",
+		id: "regexExecutors",
+		presets: ["stylisticStrict"]
+	},
+	messages: { preferExec: {
+		primary: "For consistency, prefer `RegExp.prototype.exec()` over `String.prototype.match()` when not using the global flag.",
+		secondary: ["`RegExp.prototype.exec()` is functionally identical to and slightly fewer characters than `String.prototype.match()` when the regex has no global flag.", "Choosing one by default leads to more consistent and therefore more readable code."],
+		suggestions: ["Switch from `String.prototype.match()` to `RegExp.prototype.exec()`.", "Add the global flag to the regular expression."]
+	} },
+	setup(context) {
+		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
+			if (!ts.isPropertyAccessExpression(node.expression) || node.expression.name.text !== "match" || node.arguments.length < 1 || !(getConstrainedTypeAtLocation(node.expression.expression, typeChecker).flags & ts.TypeFlags.StringLike)) return;
+			const firstArgument = node.arguments[0];
+			if (!(typeChecker.getTypeAtLocation(node.expression.expression).flags & ts.TypeFlags.StringLike)) return;
+			const flags = getRegexFlags(firstArgument, sourceFile);
+			if (flags === void 0 || flags.includes("g")) return;
+			const range = getTSNodeRange(node, sourceFile);
+			const regexText = firstArgument.getText(sourceFile);
+			context.report({
+				fix: {
+					range,
+					text: `${regexText}.exec(${node.expression.expression.getText(sourceFile)})`
+				},
+				message: "preferExec",
+				range
+			});
+		} } };
+	}
+});
+//#endregion
+export { regexExecutors_default as default };
+
+//# sourceMappingURL=regexExecutors.js.map

package/lib/rules/regexGraphemeStringLiterals.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports string literals inside character classes with the `v` flag that contain multiple graphemes.";
+    readonly id: "regexGraphemeStringLiterals";
+    readonly presets: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "multipleGraphemes", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexGraphemeStringLiterals.d.ts.map