@flint.fyi/ts 0.21.0 → 0.23.0

package/lib/rules/regexContradictoryAssertions.js

@@ -1,208 +0,0 @@
-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 };

package/lib/rules/regexControlCharacterEscapes.d.ts

@@ -1,9 +0,0 @@
-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: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferStandardEscape", undefined>;
-export default _default;

package/lib/rules/regexControlCharacterEscapes.js

@@ -1,128 +0,0 @@
-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 };

package/lib/rules/regexControlCharacters.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports control characters in regular expressions.";
-    readonly id: "regexControlCharacters";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unexpectedControlChar", undefined>;
-export default _default;

package/lib/rules/regexControlCharacters.js

@@ -1,93 +0,0 @@
-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 };

package/lib/rules/regexDigitMatchers.d.ts

@@ -1,9 +0,0 @@
-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: readonly ["stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferRange", undefined>;
-export default _default;

package/lib/rules/regexDigitMatchers.js

@@ -1,178 +0,0 @@
-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 };

package/lib/rules/regexDollarEscapes.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports replacement strings with unescaped `$` that should use `$$`.";
-    readonly id: "regexDollarEscapes";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unescapedDollar", undefined>;
-export default _default;