@flint.fyi/ts 0.15.0 → 0.18.0

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

package/lib/rules/regexControlCharacters.js

@@ -0,0 +1,95 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getRegExpLiteralDetails } from "./utils/getRegExpLiteralDetails.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/regexControlCharacters.ts
+const knownControlEscapes = {
+	0: "\\0",
+	9: "\\t",
+	10: "\\n",
+	11: "\\v",
+	12: "\\f",
+	13: "\\r"
+};
+const controlCharacterSinglePattern = /\\x(0[0-9a-fA-F]|1[0-9a-fA-F])|\\u00(0[0-9a-fA-F]|1[0-9a-fA-F])|\\u\{([0-9a-fA-F]|1[0-9a-fA-F])\}|\\c[A-Z]/g;
+const controlCharacterDoubleEscapedPattern = /\\\\x(0[0-9A-Fa-f]|1[0-9A-Fa-f])|\\\\u00(0[0-9A-Fa-f]|1[0-9A-Fa-f])|\\\\u\{([0-9A-Fa-f]|1[0-9A-Fa-f])\}|\\\\c[A-Z]/g;
+function findControlCharacters(pattern, doubleEscaped) {
+	const issues = [];
+	const searchPattern = doubleEscaped ? controlCharacterDoubleEscapedPattern : controlCharacterSinglePattern;
+	let match;
+	while ((match = searchPattern.exec(pattern)) !== null) {
+		const found = match[0];
+		const codePoint = parseControlCharCodePoint(doubleEscaped ? found.slice(1) : found);
+		if (codePoint !== void 0 && codePoint <= 31) {
+			const suggestedEscape = knownControlEscapes[codePoint];
+			issues.push({
+				codePoint,
+				end: match.index + found.length,
+				found,
+				start: match.index,
+				suggestedEscape: suggestedEscape ? doubleEscaped ? "\\" + suggestedEscape : suggestedEscape : void 0
+			});
+		}
+	}
+	return issues;
+}
+function formatCodePoint(codePoint) {
+	return `U+${codePoint.toString(16).toUpperCase().padStart(4, "0")}`;
+}
+function parseControlCharCodePoint(match) {
+	if (match.startsWith("\\x")) return parseInt(match.slice(2), 16);
+	if (match.startsWith("\\u{")) return parseInt(match.slice(3, -1), 16);
+	if (match.startsWith("\\u00")) return parseInt(match.slice(4), 16);
+	if (match.startsWith("\\c")) {
+		const letter = match[2];
+		if (letter) return letter.charCodeAt(0) - 64;
+	}
+}
+var regexControlCharacters_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports control characters in regular expressions.",
+		id: "regexControlCharacters",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { unexpectedControlChar: {
+		primary: "Unexpected control character '{{ found }}' ({{ codePoint }}) in regular expression.",
+		secondary: ["Control characters in regular expressions are rarely intentional and can cause unexpected matching behavior.", "If intentional, consider using a more readable escape sequence."],
+		suggestions: ["Remove the control character or use a standard escape."]
+	} },
+	setup(context) {
+		function reportIssues(issues, start) {
+			for (const issue of issues) context.report({
+				data: {
+					codePoint: formatCodePoint(issue.codePoint),
+					found: issue.found
+				},
+				message: "unexpectedControlChar",
+				range: {
+					begin: start + 1 + issue.start,
+					end: start + 1 + issue.end
+				}
+			});
+		}
+		function checkRegexLiteral(node, services) {
+			const { pattern, start } = getRegExpLiteralDetails(node, services);
+			reportIssues(findControlCharacters(pattern, false), start - 1);
+		}
+		function checkRegExpConstructor(node, services) {
+			if (node.expression.kind !== ts$1.SyntaxKind.Identifier || node.expression.text !== "RegExp") return;
+			const args = node.arguments;
+			if (!args?.length) return;
+			const stringLiteral = args[0];
+			if (stringLiteral.kind !== ts$1.SyntaxKind.StringLiteral) return;
+			reportIssues(findControlCharacters(stringLiteral.getText(services.sourceFile).slice(1, -1), true), stringLiteral.getStart(services.sourceFile));
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexControlCharacters_default as default };
+
+//# sourceMappingURL=regexControlCharacters.js.map

package/lib/rules/regexDigitMatchers.d.ts

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

package/lib/rules/regexDigitMatchers.js

@@ -0,0 +1,180 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getRegExpConstruction } from "./utils/getRegExpConstruction.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import { parseRegExpLiteral, visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexDigitMatchers.ts
+const ALLOWED_RANGES = [
+	{
+		max: 57,
+		min: 48
+	},
+	{
+		max: 90,
+		min: 65
+	},
+	{
+		max: 122,
+		min: 97
+	}
+];
+function checkInAllowedRange(value, rangeMin, rangeMax) {
+	const min = rangeMin ?? value;
+	const max = rangeMax ?? value;
+	return ALLOWED_RANGES.some((r) => r.min <= min && max <= r.max);
+}
+function findIssues(pattern, flags) {
+	const issues = [];
+	let ast;
+	try {
+		ast = parseRegExpLiteral(new RegExp(pattern, flags));
+	} catch {
+		return issues;
+	}
+	visitRegExpAST(ast, { onCharacterClassEnter(ccNode) {
+		const groups = [];
+		for (const element of ccNode.elements) {
+			let data;
+			if (element.type === "Character") if (checkInAllowedRange(element.value)) data = {
+				max: element,
+				min: element
+			};
+			else continue;
+			else if (element.type === "CharacterClassRange") if (checkInAllowedRange(element.min.value, element.min.value, element.max.value)) data = {
+				max: element.max,
+				min: element.min
+			};
+			else continue;
+			else continue;
+			const group = groups.find((gp) => {
+				if (!(gp.min.value - 1 <= data.max.value && data.min.value <= gp.max.value + 1)) return false;
+				const min = Math.min(gp.min.value, data.min.value);
+				return checkInAllowedRange(min, min, Math.max(gp.max.value, data.max.value));
+			});
+			if (group) {
+				if (data.min.value < group.min.value) group.min = data.min;
+				if (group.max.value < data.max.value) group.max = data.max;
+				group.nodes.push(element);
+			} else groups.push({
+				...data,
+				nodes: [element]
+			});
+		}
+		for (const group of groups) if (group.max.value - group.min.value + 1 >= 4 && group.nodes.length > 1) {
+			const newText = `${group.min.raw}-${group.max.raw}`;
+			const nodeRanges = [];
+			for (const node of group.nodes) nodeRanges.push({
+				end: node.end,
+				start: node.start
+			});
+			nodeRanges.sort((a, b) => a.start - b.start);
+			const mergedRanges = [];
+			for (const range of nodeRanges) {
+				const last = mergedRanges.at(-1);
+				if (last && last.end >= range.start) last.end = Math.max(last.end, range.end);
+				else mergedRanges.push({ ...range });
+			}
+			const firstMerged = mergedRanges[0];
+			const lastMerged = mergedRanges.at(-1);
+			if (firstMerged && lastMerged) issues.push({
+				end: lastMerged.end,
+				newText,
+				nodeRanges: mergedRanges,
+				start: firstMerged.start
+			});
+		}
+	} });
+	return issues;
+}
+function getRegexPattern(node) {
+	const text = node.text;
+	const lastSlash = text.lastIndexOf("/");
+	return {
+		flags: text.slice(lastSlash + 1),
+		pattern: text.slice(1, lastSlash)
+	};
+}
+var regexDigitMatchers_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports character classes with multiple adjacent characters that could use a range instead.",
+		id: "regexDigitMatchers",
+		presets: ["stylisticStrict"]
+	},
+	messages: { preferRange: {
+		primary: "These multiple adjacent characters can be simplified to `{{ range }}` instead.",
+		secondary: ["Character class ranges (e.g., `a-d`) are more concise and readable than listing multiple adjacent characters (e.g., `abcd`)."],
+		suggestions: ["Replace adjacent characters with '{{ range }}'."]
+	} },
+	setup(context) {
+		function checkRegexLiteral(node, { sourceFile }) {
+			const { flags, pattern } = getRegexPattern(node);
+			const issues = findIssues(pattern, flags);
+			const nodeStart = node.getStart(sourceFile);
+			for (const issue of issues) {
+				const firstRange = issue.nodeRanges[0];
+				if (!firstRange) continue;
+				context.report({
+					data: { range: issue.newText },
+					fix: issue.nodeRanges.map((range, index) => ({
+						range: {
+							begin: nodeStart + range.start,
+							end: nodeStart + range.end
+						},
+						text: index === 0 ? issue.newText : ""
+					})),
+					message: "preferRange",
+					range: {
+						begin: nodeStart + firstRange.start,
+						end: nodeStart + firstRange.end
+					}
+				});
+			}
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			const { pattern, start } = construction;
+			const issues = findIssues(pattern.replace(/\\\\/g, "\\"), construction.flags);
+			function mapPositionToSource(pos) {
+				let sourcePos = 0;
+				let patternPos = 0;
+				while (patternPos < pos && sourcePos < pattern.length) {
+					if (pattern[sourcePos] === "\\" && pattern[sourcePos + 1] === "\\") sourcePos += 2;
+					else sourcePos += 1;
+					patternPos += 1;
+				}
+				return sourcePos;
+			}
+			for (const issue of issues) {
+				const adjustedRanges = issue.nodeRanges.map((range) => ({
+					end: mapPositionToSource(range.end - 1),
+					start: mapPositionToSource(range.start - 1)
+				}));
+				const firstRange = adjustedRanges[0];
+				context.report({
+					data: { range: issue.newText.replace(/\\/g, "\\\\") },
+					fix: adjustedRanges.map((range, index) => ({
+						range: {
+							begin: start + 1 + range.start,
+							end: start + 1 + range.end
+						},
+						text: index === 0 ? issue.newText.replace(/\\/g, "\\\\") : ""
+					})),
+					message: "preferRange",
+					range: {
+						begin: start + 1 + firstRange.start,
+						end: start + 1 + firstRange.end
+					}
+				});
+			}
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexDigitMatchers_default as default };
+
+//# sourceMappingURL=regexDigitMatchers.js.map

package/lib/rules/regexDollarEscapes.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports replacement strings with unescaped `$` that should use `$$`.";
+    readonly id: "regexDollarEscapes";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unescapedDollar", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexDollarEscapes.d.ts.map