@flint.fyi/ts 0.15.0 → 0.18.1

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

package/lib/rules/regexGraphemeStringLiterals.js

@@ -0,0 +1,51 @@
+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/regexGraphemeStringLiterals.ts
+const segmenter = new Intl.Segmenter();
+function buildAlternativeExample(stringAlternative) {
+	return `(?:${stringAlternative.parent.alternatives.filter(isMultipleGraphemes).map((alternative) => alternative.raw).join("|")}|[...])`;
+}
+function isMultipleGraphemes(stringAlternative) {
+	if (stringAlternative.elements.length <= 1) return false;
+	const string = String.fromCodePoint(...stringAlternative.elements.map((element) => element.value));
+	return [...segmenter.segment(string)].length > 1;
+}
+var regexGraphemeStringLiterals_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports string literals inside character classes with the `v` flag that contain multiple graphemes.",
+		id: "regexGraphemeStringLiterals",
+		presets: ["stylisticStrict"]
+	},
+	messages: { multipleGraphemes: {
+		primary: "This literal contains multiple graphemes in the `\\q{}` matcher intended for single graphemes.",
+		secondary: ["The `\\q{}` syntax is designed for single extended grapheme clusters like emoji sequences.", "Using it for multiple \"graphemes\" (visual characters) is often a mistake."],
+		suggestions: ["If matching multi-character strings, consider using alternation: '{{ alternative }}'."]
+	} },
+	setup(context) {
+		return { visitors: { RegularExpressionLiteral: (node, { sourceFile }) => {
+			const text = node.getText(sourceFile);
+			const match = /^\/(.+)\/([dgimsuyv]*)$/.exec(text);
+			if (!match) return;
+			const [, pattern, flags] = match;
+			if (!pattern || !flags?.includes("v")) return;
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			const nodeRange = getTSNodeRange(node, sourceFile);
+			visitRegExpAST(regexpAst, { onStringAlternativeEnter(stringAlternative) {
+				if (!isMultipleGraphemes(stringAlternative)) return;
+				const alternative = buildAlternativeExample(stringAlternative);
+				context.report({
+					data: { alternative },
+					message: "multipleGraphemes",
+					range: nodeRange
+				});
+			} });
+		} } };
+	}
+});
+//#endregion
+export { regexGraphemeStringLiterals_default as default };
+
+//# sourceMappingURL=regexGraphemeStringLiterals.js.map

package/lib/rules/regexHexadecimalEscapes.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports regex character escapes that can be expressed more consistently using hexadecimal escapes.";
+    readonly id: "regexHexadecimalEscapes";
+    readonly presets: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferHexEscape", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexHexadecimalEscapes.d.ts.map

package/lib/rules/regexHexadecimalEscapes.js

@@ -0,0 +1,71 @@
+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/regexHexadecimalEscapes.ts
+function getEscapeType(raw) {
+	if (raw.length === 1) return "literal";
+	if (!raw.startsWith("\\")) return;
+	const second = raw[1];
+	if (second === "x") return "hexadecimal";
+	if (second === "u") return "unicode";
+	if (second === "c") return "control";
+	if (second !== void 0 && second >= "0" && second <= "7") return "octal";
+}
+function toHexEscape(codePoint) {
+	return `\\x${codePoint.toString(16).padStart(2, "0")}`;
+}
+var regexHexadecimalEscapes_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports regex character escapes that can be expressed more consistently using hexadecimal escapes.",
+		id: "regexHexadecimalEscapes",
+		presets: ["stylisticStrict"]
+	},
+	messages: { preferHexEscape: {
+		primary: "Prefer the more succinct hexadecimal escape `{{ hexEscape }}` over {{ escapeType }} escape `{{ found }}`.",
+		secondary: ["Hexadecimal escapes are more concise for characters in the 0x00-0xFF range."],
+		suggestions: ["Replace `{{ found }}` with `{{ hexEscape }}`."]
+	} },
+	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);
+			visitRegExpAST(regexpAst, { onCharacterEnter(charNode) {
+				if (charNode.value > 255) return;
+				const escapeType = getEscapeType(charNode.raw);
+				if (!escapeType) return;
+				if (escapeType === "unicode" && (charNode.raw.startsWith("\\u00") || charNode.raw.startsWith("\\u{") && charNode.value <= 255)) {
+					const hexEscape = toHexEscape(charNode.value);
+					context.report({
+						data: {
+							escapeType,
+							found: charNode.raw,
+							hexEscape
+						},
+						fix: {
+							range: {
+								begin: range.begin + 1 + charNode.start,
+								end: range.begin + 1 + charNode.end
+							},
+							text: hexEscape
+						},
+						message: "preferHexEscape",
+						range: {
+							begin: range.begin + 1 + charNode.start,
+							end: range.begin + 1 + charNode.end
+						}
+					});
+				}
+			} });
+		} } };
+	}
+});
+//#endregion
+export { regexHexadecimalEscapes_default as default };
+
+//# sourceMappingURL=regexHexadecimalEscapes.js.map

package/lib/rules/regexIgnoreCaseFlags.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports regex patterns that can be simplified by using the i (ignore case) flag.";
+    readonly id: "regexIgnoreCaseFlags";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "useIgnoreCase", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexIgnoreCaseFlags.d.ts.map