@flint.fyi/ts 0.14.6 → 0.18.0

package/lib/rules/regexCharacterClasses.js

@@ -0,0 +1,234 @@
+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/regexCharacterClasses.ts
+const reservedDoublePunctuatorCharacters = new Set([
+	"!",
+	"#",
+	"$",
+	"%",
+	"&",
+	"*",
+	"+",
+	",",
+	".",
+	":",
+	";",
+	"<",
+	"=",
+	">",
+	"?",
+	"@",
+	"^",
+	"`",
+	"~"
+]);
+function categorizeAlternative(alternative) {
+	if (isSingleCharElement(alternative.elements)) {
+		const element = alternative.elements[0];
+		const elements = toCharacterClassElement(element);
+		if (elements) return {
+			elements,
+			isCharacter: true,
+			raw: alternative.raw
+		};
+	}
+	return {
+		isCharacter: false,
+		raw: alternative.raw
+	};
+}
+function containsCharacterClass(alternatives) {
+	for (const alt of alternatives) if (alt.isCharacter && alt.raw.startsWith("[") && !alt.raw.startsWith("[^")) return true;
+	return false;
+}
+function elementsToCharacterClass(elements) {
+	const parts = [];
+	for (const element of elements) switch (element.type) {
+		case "Character":
+			if (element.raw === "-") parts.push("\\-");
+			else if (element.raw === "]") parts.push("\\]");
+			else parts.push(element.raw);
+			break;
+		case "CharacterClass":
+		case "CharacterClassRange":
+		case "CharacterSet":
+		case "ClassStringDisjunction":
+		case "ExpressionCharacterClass":
+			parts.push(element.raw);
+			break;
+	}
+	if (!parts.length) return "[]";
+	if (parts[0]?.[0] === "^") parts[0] = `\\${parts[0]}`;
+	for (let i = 1; i < parts.length; i++) {
+		const prev = parts[i - 1];
+		const curr = parts[i];
+		if (prev && curr) {
+			const pChar = prev.slice(-1);
+			const cChar = curr[0];
+			if (cChar && reservedDoublePunctuatorCharacters.has(cChar) && cChar === pChar && !prev.endsWith(`\\${pChar}`)) parts[i - 1] = `${prev.slice(0, -1)}\\${pChar}`;
+		}
+	}
+	return `[${parts.join("")}]`;
+}
+function getParentPrefixAndSuffix(parent) {
+	switch (parent.type) {
+		case "Assertion": return [`(?${parent.kind === "lookahead" ? "" : "<"}${parent.negate ? "!" : "="}`, ")"];
+		case "CapturingGroup":
+			if (parent.name !== null) return [`(?<${parent.name}>`, ")"];
+			return ["(", ")"];
+		case "Group": return ["(?:", ")"];
+		case "Pattern": return ["", ""];
+	}
+}
+function isSingleCharElement(elements) {
+	if (elements.length !== 1) return false;
+	const element = elements[0];
+	return element !== void 0 && (element.type === "Character" || element.type === "CharacterClass" || element.type === "CharacterSet" || element.type === "ExpressionCharacterClass");
+}
+function mergeCharacterAlternatives(a, b) {
+	const elements = [...a.elements, ...b.elements];
+	return {
+		elements,
+		isCharacter: true,
+		raw: elementsToCharacterClass(elements)
+	};
+}
+function optimizeAlternatives(alternatives) {
+	const result = [...alternatives];
+	for (let i = 0; i < result.length - 1; i++) {
+		let current = result[i];
+		if (!current?.isCharacter) continue;
+		for (let j = i + 1; j < result.length; j++) {
+			const next = result[j];
+			if (!next) continue;
+			if (next.isCharacter) {
+				current = mergeCharacterAlternatives(current, next);
+				result.splice(j, 1);
+				j--;
+			} else break;
+		}
+		result[i] = current;
+	}
+	return result;
+}
+function toCharacterClassElement(element) {
+	switch (element.type) {
+		case "Character": return [element];
+		case "CharacterClass":
+			if (element.negate && !element.unicodeSets) return;
+			if (element.negate) return [element];
+			return element.elements;
+		case "CharacterSet":
+			if (element.kind === "any") return;
+			return [element];
+		case "ExpressionCharacterClass": return [element];
+		default: return;
+	}
+}
+var regexCharacterClasses_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports regex alternations that can be simplified to character classes.",
+		id: "regexCharacterClasses",
+		presets: ["stylisticStrict"]
+	},
+	messages: { preferCharacterClass: {
+		primary: "This alternation can be simplified to a character class '{{ replacement }}'.",
+		secondary: ["Character classes are more efficient than alternations and don't require backtracking."],
+		suggestions: ["Replace the alternation with a character class '{{ replacement }}'."]
+	} },
+	setup(context) {
+		function processAlternatives(node) {
+			const alternatives = node.alternatives;
+			if (alternatives.length < 2) return;
+			const parsed = alternatives.map(categorizeAlternative);
+			const characterCount = parsed.filter((a) => a.isCharacter).length;
+			if (characterCount < 2) return;
+			if (characterCount < 3 && !containsCharacterClass(parsed)) return;
+			const optimized = optimizeAlternatives(parsed);
+			if (optimized.length === parsed.length) return;
+			const replacement = optimized.map((a) => a.raw).join("|");
+			const [prefix, suffix] = getParentPrefixAndSuffix(node);
+			return {
+				fixedPattern: prefix + replacement + suffix,
+				replacement
+			};
+		}
+		return { visitors: { RegularExpressionLiteral: (node, { sourceFile }) => {
+			const text = node.getText(sourceFile);
+			const match = /^\/(.+)\/([dgimsuyv]*)$/.exec(text);
+			if (!match) return;
+			const [, pattern, flags = ""] = match;
+			if (!pattern) return;
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			const nodeRange = getTSNodeRange(node, sourceFile);
+			visitRegExpAST(regexpAst, {
+				onAssertionEnter(assertion) {
+					if (assertion.kind === "lookahead" || assertion.kind === "lookbehind") {
+						const result = processAlternatives(assertion);
+						if (result) {
+							const newPattern = pattern.slice(0, assertion.start) + result.fixedPattern + pattern.slice(assertion.end);
+							context.report({
+								data: { replacement: result.replacement },
+								fix: {
+									range: nodeRange,
+									text: `/${newPattern}/${flags}`
+								},
+								message: "preferCharacterClass",
+								range: nodeRange
+							});
+						}
+					}
+				},
+				onCapturingGroupEnter(group) {
+					const result = processAlternatives(group);
+					if (result) {
+						const newPattern = pattern.slice(0, group.start) + result.fixedPattern + pattern.slice(group.end);
+						context.report({
+							data: { replacement: result.replacement },
+							fix: {
+								range: nodeRange,
+								text: `/${newPattern}/${flags}`
+							},
+							message: "preferCharacterClass",
+							range: nodeRange
+						});
+					}
+				},
+				onGroupEnter(group) {
+					const result = processAlternatives(group);
+					if (result) {
+						const newPattern = pattern.slice(0, group.start) + result.fixedPattern + pattern.slice(group.end);
+						context.report({
+							data: { replacement: result.replacement },
+							fix: {
+								range: nodeRange,
+								text: `/${newPattern}/${flags}`
+							},
+							message: "preferCharacterClass",
+							range: nodeRange
+						});
+					}
+				},
+				onPatternEnter(patternNode) {
+					const result = processAlternatives(patternNode);
+					if (result) context.report({
+						data: { replacement: result.replacement },
+						fix: {
+							range: nodeRange,
+							text: `/${result.replacement}/${flags}`
+						},
+						message: "preferCharacterClass",
+						range: nodeRange
+					});
+				}
+			});
+		} } };
+	}
+});
+//#endregion
+export { regexCharacterClasses_default as default };
+
+//# sourceMappingURL=regexCharacterClasses.js.map

package/lib/rules/regexConciseCharacterClassNegations.d.ts

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

package/lib/rules/regexConciseCharacterClassNegations.js

@@ -0,0 +1,52 @@
+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/regexConciseCharacterClassNegations.ts
+function getNegationText(node) {
+	if (node.type === "ExpressionCharacterClass") return `[${node.raw.slice(2, -1)}]`;
+	const kind = node.raw[1];
+	if (!kind) return;
+	return `\\${kind.toLowerCase() === kind ? kind.toUpperCase() : kind.toLowerCase()}${node.raw.slice(2)}`;
+}
+var regexConciseCharacterClassNegations_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports negated character classes that can use shorthand escapes.",
+		id: "regexConciseCharacterClassNegations",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { preferNegatedEscape: {
+		primary: "Use '{{ replacement }}' instead of negated character class.",
+		secondary: ["Shorthand escape sequences like \\D, \\W, and \\S are more concise than negated character classes."],
+		suggestions: ["Replace the negated character class with '{{ replacement }}'."]
+	} },
+	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) return;
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			const hasIgnoreCase = flags?.includes("i") ?? false;
+			visitRegExpAST(regexpAst, { onCharacterClassEnter(characterClassNode) {
+				if (!characterClassNode.negate || characterClassNode.elements.length !== 1) return;
+				const element = characterClassNode.elements[0];
+				if (element.type !== "CharacterSet" && element.type !== "ExpressionCharacterClass") return;
+				if (element.type === "CharacterSet" && element.kind === "property" && hasIgnoreCase) return;
+				const replacement = getNegationText(element);
+				if (!replacement) return;
+				context.report({
+					data: { replacement },
+					message: "preferNegatedEscape",
+					range: getTSNodeRange(node, sourceFile)
+				});
+			} });
+		} } };
+	}
+});
+//#endregion
+export { regexConciseCharacterClassNegations_default as default };
+
+//# sourceMappingURL=regexConciseCharacterClassNegations.js.map

package/lib/rules/regexContradictoryAssertions.d.ts

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

package/lib/rules/regexContradictoryAssertions.js

@@ -0,0 +1,210 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getRegExpConstruction } from "./utils/getRegExpConstruction.js";
+import { getRegExpLiteralDetails } from "./utils/getRegExpLiteralDetails.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+//#region src/rules/regexContradictoryAssertions.ts
+function findContradictions(pattern, doubleEscaped) {
+	const contradictions = [];
+	const wordBoundaryRegex = doubleEscaped ? /\\\\b/g : /\\b/g;
+	let match;
+	while ((match = wordBoundaryRegex.exec(pattern)) !== null) {
+		const assertionStart = match.index;
+		const assertionEnd = match.index + match[0].length;
+		const characterBefore = getCharBeforeAssertion(pattern, assertionStart, doubleEscaped);
+		if (!characterBefore) continue;
+		const optional = parseOptionalQuantifier(pattern, assertionEnd, doubleEscaped);
+		if (!optional) continue;
+		const beforeIsWord = isWordCharacter(characterBefore);
+		const elementIsWord = isWordCharacter(getElementChar(optional.element, doubleEscaped));
+		const afterOptional = getCharRepresentation(pattern, optional.end, doubleEscaped);
+		if (!afterOptional) continue;
+		const afterIsWord = isWordCharacter(afterOptional.character);
+		if (beforeIsWord === elementIsWord) contradictions.push({
+			assertionRaw: match[0],
+			elementRaw: optional.element,
+			end: optional.end,
+			start: assertionEnd,
+			type: "cannotEnter"
+		});
+		else if (beforeIsWord === afterIsWord) contradictions.push({
+			assertionRaw: match[0],
+			elementRaw: optional.element,
+			end: optional.end,
+			start: assertionEnd,
+			type: "alwaysEnter"
+		});
+	}
+	return contradictions;
+}
+function getCharacterFromEscape(escape) {
+	switch (escape) {
+		case "\\\\d":
+		case "\\d": return "0";
+		case "\\\\D":
+		case "\\D": return " ";
+		case "\\\\s":
+		case "\\s": return " ";
+		case "\\\\S":
+		case "\\S": return "a";
+		case "\\\\w":
+		case "\\w": return "a";
+		case "\\\\W":
+		case "\\W": return " ";
+		default: return;
+	}
+}
+function getCharBeforeAssertion(pattern, assertionStart, doubleEscaped) {
+	if (assertionStart <= 0) return;
+	if (doubleEscaped) {
+		if (assertionStart >= 3 && pattern[assertionStart - 3] === "\\") {
+			const charResult = getCharacterFromEscape(pattern.slice(assertionStart - 3, assertionStart));
+			if (charResult) return charResult;
+			return pattern[assertionStart - 1];
+		}
+		return pattern[assertionStart - 1];
+	}
+	if (assertionStart >= 2 && pattern[assertionStart - 2] === "\\") {
+		const charResult = getCharacterFromEscape(pattern.slice(assertionStart - 2, assertionStart));
+		if (charResult) return charResult;
+		return pattern[assertionStart - 1];
+	}
+	return pattern[assertionStart - 1];
+}
+function getCharRepresentation(pattern, startIndex, doubleEscaped) {
+	if (startIndex >= pattern.length) return;
+	const remaining = pattern.slice(startIndex);
+	if (doubleEscaped) {
+		if (remaining.startsWith("\\\\")) {
+			const charResult = getCharacterFromEscape(remaining.slice(0, 3));
+			if (charResult) return {
+				character: charResult,
+				length: 3
+			};
+			if (remaining.length >= 3 && remaining[2]) return {
+				character: remaining[2],
+				length: 3
+			};
+			return;
+		}
+	} else if (remaining.startsWith("\\")) {
+		const twoCharEscape = remaining.slice(0, 2);
+		const charResult = getCharacterFromEscape(twoCharEscape);
+		if (charResult) return {
+			character: charResult,
+			length: 2
+		};
+		if (twoCharEscape === "\\b" || twoCharEscape === "\\B" || twoCharEscape === "\\0" || remaining.length < 1 || !remaining[1]) return;
+		return {
+			character: remaining[1],
+			length: 2
+		};
+	}
+	return {
+		character: remaining[0],
+		length: 1
+	};
+}
+function getElementChar(element, doubleEscaped) {
+	if (element.startsWith("[")) {
+		const inner = element.slice(1, element.lastIndexOf("]"));
+		if (!inner.length || inner.startsWith("^")) return;
+		if (inner.includes("-") && inner.length > 1) {
+			const rangeMatch = /^(.)/.exec(inner);
+			if (rangeMatch) return rangeMatch[1];
+		}
+		return inner[0];
+	}
+	const withoutQuantifier = element.replace(/[*?]$/, "");
+	if (doubleEscaped && withoutQuantifier.startsWith("\\\\")) {
+		const characterResult = getCharacterFromEscape(withoutQuantifier);
+		if (characterResult) return characterResult;
+		if (withoutQuantifier.length >= 3) return withoutQuantifier[2];
+		return;
+	}
+	if (!doubleEscaped && withoutQuantifier.startsWith("\\")) {
+		const charResult = getCharacterFromEscape(withoutQuantifier);
+		if (charResult) return charResult;
+		if (withoutQuantifier.length >= 2) return withoutQuantifier[1];
+		return;
+	}
+	return withoutQuantifier;
+}
+function isWordCharacter(character) {
+	return character ? /^\w$/.test(character) : false;
+}
+function parseOptionalQuantifier(pattern, startIndex, doubleEscaped) {
+	if (startIndex >= pattern.length) return;
+	const remaining = pattern.slice(startIndex);
+	const characterClassMatch = /^\[[^\]]*\][*?]/.exec(remaining);
+	if (characterClassMatch) return {
+		element: characterClassMatch[0],
+		end: startIndex + characterClassMatch[0].length
+	};
+	const escapePattern = doubleEscaped ? /^(?:\\\\.|.)[*?]/ : /^(?:\\.|.)[*?]/;
+	const simpleMatch = remaining.match(escapePattern);
+	if (simpleMatch) return {
+		element: simpleMatch[0],
+		end: startIndex + simpleMatch[0].length
+	};
+}
+var regexContradictoryAssertions_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports elements in regular expressions that contradict assertions.",
+		id: "regexContradictoryAssertions",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: {
+		alwaysEnter: {
+			primary: "The quantifier '{{ element }}' is always entered despite having a minimum of 0.",
+			secondary: ["The quantifier appears after an assertion that forces it to be matched at least once.", "This can lead to unexpected matching behavior."],
+			suggestions: ["Change the quantifier minimum to 1."]
+		},
+		cannotEnter: {
+			primary: "The quantifier '{{ element }}' can never be entered because it contradicts the assertion '{{ assertion }}'.",
+			secondary: ["The quantifier element would need to match characters that the assertion explicitly forbids.", "This means the quantifier is effectively dead code."],
+			suggestions: ["Remove the quantifier or fix the pattern."]
+		}
+	},
+	setup(context) {
+		function checkRegexLiteral(node, services) {
+			const { pattern, start } = getRegExpLiteralDetails(node, services);
+			const contradictions = findContradictions(pattern, false);
+			for (const contradiction of contradictions) context.report({
+				data: {
+					assertion: contradiction.assertionRaw,
+					element: contradiction.elementRaw
+				},
+				message: contradiction.type === "alwaysEnter" ? "alwaysEnter" : "cannotEnter",
+				range: {
+					begin: start + contradiction.start,
+					end: start + contradiction.end
+				}
+			});
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			const contradictions = findContradictions(construction.pattern, true);
+			for (const contradiction of contradictions) context.report({
+				data: {
+					assertion: contradiction.assertionRaw,
+					element: contradiction.elementRaw
+				},
+				message: contradiction.type === "alwaysEnter" ? "alwaysEnter" : "cannotEnter",
+				range: {
+					begin: construction.start + 1 + contradiction.start,
+					end: construction.start + 1 + contradiction.end
+				}
+			});
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexContradictoryAssertions_default as default };
+
+//# sourceMappingURL=regexContradictoryAssertions.js.map

package/lib/rules/regexControlCharacterEscapes.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports control characters that are not escaped using standard escape sequences.";
+    readonly id: "regexControlCharacterEscapes";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferStandardEscape", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexControlCharacterEscapes.d.ts.map

package/lib/rules/regexControlCharacterEscapes.js

@@ -0,0 +1,130 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getRegExpConstruction } from "./utils/getRegExpConstruction.js";
+import { getRegExpLiteralDetails } from "./utils/getRegExpLiteralDetails.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+//#region src/rules/regexControlCharacterEscapes.ts
+const controlCharacters = {
+	"\\0": "\\0",
+	"\\cI": "\\t",
+	"\\cJ": "\\n",
+	"\\cK": "\\v",
+	"\\cL": "\\f",
+	"\\cM": "\\r",
+	"\\u000A": "\\n",
+	"\\u000a": "\\n",
+	"\\u000B": "\\v",
+	"\\u000b": "\\v",
+	"\\u000C": "\\f",
+	"\\u000c": "\\f",
+	"\\u000D": "\\r",
+	"\\u000d": "\\r",
+	"\\u0000": "\\0",
+	"\\u0009": "\\t",
+	"\\u{0}": "\\0",
+	"\\u{9}": "\\t",
+	"\\u{a}": "\\n",
+	"\\u{A}": "\\n",
+	"\\u{b}": "\\v",
+	"\\u{B}": "\\v",
+	"\\u{c}": "\\f",
+	"\\u{C}": "\\f",
+	"\\u{d}": "\\r",
+	"\\u{D}": "\\r",
+	"\\x0A": "\\n",
+	"\\x0a": "\\n",
+	"\\x0B": "\\v",
+	"\\x0b": "\\v",
+	"\\x0C": "\\f",
+	"\\x0c": "\\f",
+	"\\x0D": "\\r",
+	"\\x0d": "\\r",
+	"\\x00": "\\0",
+	"\\x09": "\\t"
+};
+const controlDoubleEscapePattern = /\\\\(?:x0[09A-Da-d]|u000[09A-Da-d]|u\{[09A-Da-d]\}|c[I-M])/g;
+const controlSingleEscapePattern = /\\(?:x0[09A-Da-d]|u000[09A-Da-d]|u\{[09A-Da-d]\}|c[I-M])/g;
+function findControlCharacterIssues(pattern, doubleEscaped) {
+	const issues = [];
+	const searchPattern = doubleEscaped ? controlDoubleEscapePattern : controlSingleEscapePattern;
+	let match;
+	while ((match = searchPattern.exec(pattern)) !== null) {
+		const found = match[0];
+		const normalizedKey = doubleEscaped ? found.slice(1) : found;
+		const expected = controlCharacters[normalizedKey];
+		if (expected && normalizedKey !== expected) issues.push({
+			end: match.index + found.length,
+			expected: doubleEscaped ? "\\" + expected : expected,
+			found,
+			start: match.index
+		});
+	}
+	return issues;
+}
+var regexControlCharacterEscapes_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports control characters that are not escaped using standard escape sequences.",
+		id: "regexControlCharacterEscapes",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { preferStandardEscape: {
+		primary: "Prefer standard escape sequence '{{ expected }}' over '{{ found }}'.",
+		secondary: ["Standard escape sequences like \\t, \\n, \\r are more readable than hex or unicode escapes."],
+		suggestions: ["Replace '{{ found }}' with '{{ expected }}'."]
+	} },
+	setup(context) {
+		function checkRegexLiteral(node, services) {
+			const { pattern, start } = getRegExpLiteralDetails(node, services);
+			const issues = findControlCharacterIssues(pattern, false);
+			for (const issue of issues) context.report({
+				data: {
+					expected: issue.expected,
+					found: issue.found
+				},
+				fix: {
+					range: {
+						begin: start + issue.start,
+						end: start + issue.end
+					},
+					text: issue.expected
+				},
+				message: "preferStandardEscape",
+				range: {
+					begin: start + issue.start,
+					end: start + issue.end
+				}
+			});
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			const issues = findControlCharacterIssues(construction.pattern, true);
+			for (const issue of issues) context.report({
+				data: {
+					expected: issue.expected,
+					found: issue.found
+				},
+				fix: {
+					range: {
+						begin: construction.start + 1 + issue.start,
+						end: construction.start + 1 + issue.end
+					},
+					text: issue.expected
+				},
+				message: "preferStandardEscape",
+				range: {
+					begin: construction.start + 1 + issue.start,
+					end: construction.start + 1 + issue.end
+				}
+			});
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexControlCharacterEscapes_default as default };
+
+//# sourceMappingURL=regexControlCharacterEscapes.js.map

package/lib/rules/regexControlCharacters.d.ts

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