@flint.fyi/ts 0.21.0 → 0.23.0

package/lib/rules/unnecessaryBlocks.js

@@ -1,58 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts, { SyntaxKind } from "typescript";
-import { isNodeFlagSet } from "ts-api-utils";
-//#region src/rules/unnecessaryBlocks.ts
-function isUsingVariableStatement(node) {
-	return node.kind === SyntaxKind.VariableStatement && isNodeFlagSet(node.declarationList, ts.NodeFlags.Using);
-}
-function isValidBlock(node) {
-	switch (node.parent.kind) {
-		case SyntaxKind.ArrowFunction:
-		case SyntaxKind.CaseClause:
-		case SyntaxKind.CatchClause:
-		case SyntaxKind.Constructor:
-		case SyntaxKind.DefaultClause:
-		case SyntaxKind.DoStatement:
-		case SyntaxKind.ForInStatement:
-		case SyntaxKind.ForOfStatement:
-		case SyntaxKind.ForStatement:
-		case SyntaxKind.FunctionDeclaration:
-		case SyntaxKind.FunctionExpression:
-		case SyntaxKind.GetAccessor:
-		case SyntaxKind.IfStatement:
-		case SyntaxKind.LabeledStatement:
-		case SyntaxKind.MethodDeclaration:
-		case SyntaxKind.ModuleBlock:
-		case SyntaxKind.SetAccessor:
-		case SyntaxKind.TryStatement:
-		case SyntaxKind.WhileStatement:
-		case SyntaxKind.WithStatement: return true;
-		default: return node.statements.some(isUsingVariableStatement);
-	}
-}
-var unnecessaryBlocks_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports standalone block statements that don't create a meaningful scope.",
-		id: "unnecessaryBlocks",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { unnecessaryBlock: {
-		primary: "This standalone block statement is unnecessary and doesn't change any variable scopes.",
-		secondary: ["Standalone block statements that aren't part of control flow (if/else, loops, switch) or don't create a meaningful lexical scope can be confusing and should be avoided.", "In modern JavaScript and TypeScript, blocks primarily serve to create lexical scope for `let` and `const` variables, but this is often better achieved through other means."],
-		suggestions: ["Remove the block statement and move its contents to the parent scope.", "If you need lexical scoping, consider using an IIFE (Immediately Invoked Function Expression) or extracting to a separate function."]
-	} },
-	setup(context) {
-		return { visitors: { Block: (node, { sourceFile }) => {
-			if (!isValidBlock(node)) context.report({
-				message: "unnecessaryBlock",
-				range: {
-					begin: node.getStart(sourceFile),
-					end: node.getStart(sourceFile) + 1
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { unnecessaryBlocks_default as default };

package/lib/rules/unnecessaryBooleanCasts.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports unnecessary boolean casts.";
-    readonly id: "unnecessaryBooleanCasts";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessary", undefined>;
-export default _default;

package/lib/rules/unnecessaryBooleanCasts.js

@@ -1,56 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { isInBooleanContext } from "./utils/isInBooleanContext.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/unnecessaryBooleanCasts.ts
-function getNodeText(node, sourceFile) {
-	return sourceFile.text.slice(node.getStart(sourceFile), node.getEnd());
-}
-function isBooleanCall(node) {
-	return ts.isIdentifier(node.expression) && node.expression.text === "Boolean";
-}
-function isDoubleNegation(node) {
-	if (node.operator !== ts.SyntaxKind.ExclamationToken) return false;
-	const operand = node.operand;
-	if (ts.isPrefixUnaryExpression(operand) && operand.operator === ts.SyntaxKind.ExclamationToken) return true;
-	return false;
-}
-var unnecessaryBooleanCasts_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports unnecessary boolean casts.",
-		id: "unnecessaryBooleanCasts",
-		presets: ["logical"]
-	},
-	messages: { unnecessary: {
-		primary: "Casting this value to a boolean is unnecessary in this context.",
-		secondary: ["The value is already in a boolean context.", "Using `{{ cast }}` to cast it does not change program behavior."],
-		suggestions: ["Remove the `{{ cast }}` call."]
-	} },
-	setup(context) {
-		function reportCast(cast, outer, inner, sourceFile) {
-			const range = getTSNodeRange(outer, sourceFile);
-			context.report({
-				data: { cast },
-				fix: {
-					range,
-					text: getNodeText(inner, sourceFile)
-				},
-				message: "unnecessary",
-				range
-			});
-		}
-		return { visitors: {
-			CallExpression(node, { sourceFile }) {
-				if (!isBooleanCall(node) || !isInBooleanContext(node)) return;
-				const argument = node.arguments[0];
-				reportCast("Boolean()", node, argument, sourceFile);
-			},
-			PrefixUnaryExpression(node, { sourceFile }) {
-				if (!isDoubleNegation(node) || !isInBooleanContext(node)) return;
-				reportCast("!!", node, node.operand.operand, sourceFile);
-			}
-		} };
-	}
-});
-//#endregion
-export { unnecessaryBooleanCasts_default as default };

package/lib/rules/unnecessaryCatches.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports catch clauses that only rethrow the caught error without modification.";
-    readonly id: "unnecessaryCatches";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessaryCatch", undefined>;
-export default _default;

package/lib/rules/unnecessaryCatches.js

@@ -1,46 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/unnecessaryCatches.ts
-var unnecessaryCatches_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports catch clauses that only rethrow the caught error without modification.",
-		id: "unnecessaryCatches",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { unnecessaryCatch: {
-		primary: "This catch clause is unnecessary, as it only rethrows the exception without modification.",
-		secondary: ["A catch clause that only rethrows the caught error adds no value and creates unnecessary code complexity.", "Removing such catch clauses allows errors to propagate naturally without the overhead of an unnecessary try-catch block."],
-		suggestions: ["Remove the try-catch block if the catch clause only rethrows the error, or add meaningful error handling logic to the catch clause."]
-	} },
-	setup(context) {
-		return { visitors: { CatchClause: (node, { sourceFile }) => {
-			if (!node.variableDeclaration) return;
-			const statements = node.block.statements;
-			if (statements.length !== 1) return;
-			const statement = statements[0];
-			if (statement.kind !== SyntaxKind.ThrowStatement) return;
-			const catchVariable = node.variableDeclaration.name;
-			const thrownExpression = statement.expression;
-			if (catchVariable.kind !== SyntaxKind.Identifier || thrownExpression.kind !== SyntaxKind.Identifier) return;
-			if (catchVariable.text !== thrownExpression.text) return;
-			const range = {
-				begin: node.getStart(sourceFile),
-				end: node.getStart(sourceFile) + 5
-			};
-			context.report({
-				fix: {
-					range: {
-						begin: node.parent.tryBlock.getEnd(),
-						end: node.getEnd()
-					},
-					text: ""
-				},
-				message: "unnecessaryCatch",
-				range
-			});
-		} } };
-	}
-});
-//#endregion
-export { unnecessaryCatches_default as default };

package/lib/rules/unnecessaryComparisons.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports comparisons that are always true, always false, or can be simplified.";
-    readonly id: "unnecessaryComparisons";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "impossibleRange" | "ineffectiveCheck" | "redundantComparison" | "selfComparison", undefined>;
-export default _default;

package/lib/rules/unnecessaryComparisons.js

@@ -1,291 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { isComparisonOperator } from "./utils/operators.js";
-import { getStaticNumberValue, getTSNodeRange, hasSameTokens, typescriptLanguage, unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/unnecessaryComparisons.ts
-function checkImpossibleRange(comparisons, sourceFile) {
-	for (const [i, a] of comparisons.entries()) for (const b of comparisons.slice(i + 1)) {
-		if (a.numericValue === null || b.numericValue === null) continue;
-		if (!hasSameTokens(a.variable, b.variable, sourceFile)) continue;
-		let lowerBound;
-		let upperBound;
-		if (a.direction === "upper" && b.direction === "lower") {
-			upperBound = a;
-			lowerBound = b;
-		} else if (a.direction === "lower" && b.direction === "upper") {
-			upperBound = b;
-			lowerBound = a;
-		}
-		if (!upperBound || !lowerBound) continue;
-		const upper = upperBound.numericValue;
-		const lower = lowerBound.numericValue;
-		if (upper === null || lower === null) continue;
-		if (upper < lower) return {
-			lowerBound,
-			upperBound
-		};
-		if (upper === lower) {
-			if (upperBound.isStrict || lowerBound.isStrict) return {
-				lowerBound,
-				upperBound
-			};
-		}
-	}
-	return null;
-}
-function checkIneffectiveChecks(comparisons, sourceFile) {
-	for (const [i, a] of comparisons.entries()) for (const b of comparisons.slice(i + 1)) {
-		if (a.numericValue === null || b.numericValue === null) continue;
-		if (!hasSameTokens(a.variable, b.variable, sourceFile)) continue;
-		if (a.direction !== b.direction) continue;
-		if (a.direction === "upper") {
-			if (a.numericValue < b.numericValue) return {
-				stronger: a,
-				weaker: b
-			};
-			if (b.numericValue < a.numericValue) return {
-				stronger: b,
-				weaker: a
-			};
-			if (a.numericValue === b.numericValue) {
-				if (a.isStrict && !b.isStrict) return {
-					stronger: a,
-					weaker: b
-				};
-				if (!a.isStrict && b.isStrict) return {
-					stronger: b,
-					weaker: a
-				};
-			}
-		}
-		if (a.direction === "lower") {
-			if (a.numericValue > b.numericValue) return {
-				stronger: a,
-				weaker: b
-			};
-			if (b.numericValue > a.numericValue) return {
-				stronger: b,
-				weaker: a
-			};
-			if (a.numericValue === b.numericValue) {
-				if (a.isStrict && !b.isStrict) return {
-					stronger: a,
-					weaker: b
-				};
-				if (!a.isStrict && b.isStrict) return {
-					stronger: b,
-					weaker: a
-				};
-			}
-		}
-	}
-	return null;
-}
-function checkRedundantOrComparison(comparisons, sourceFile) {
-	for (const [index, a] of comparisons.entries()) for (const b of comparisons.slice(index + 1)) {
-		if (!hasSameTokens(a.variable, b.variable, sourceFile) || !hasSameTokens(a.node.left, b.node.left, sourceFile) || !hasSameTokens(a.node.right, b.node.right, sourceFile)) {
-			if (!hasSameTokens(a.node.left, b.node.right, sourceFile) || !hasSameTokens(a.node.right, b.node.left, sourceFile)) continue;
-		}
-		const suggestion = getSimplifiedOperator(a.operatorKind, b.operatorKind);
-		if (suggestion) return {
-			first: a,
-			second: b,
-			suggestion
-		};
-	}
-	return null;
-}
-function collectComparisonsFromChain(node, operatorKind) {
-	const results = [];
-	function traverse(expr) {
-		const unwrapped = unwrapParenthesizedNode(expr);
-		if (unwrapped.kind !== SyntaxKind.BinaryExpression) return;
-		if (unwrapped.operatorToken.kind === operatorKind) {
-			traverse(unwrapped.left);
-			traverse(unwrapped.right);
-			return;
-		}
-		const info = extractComparisonInfo(unwrapped);
-		if (info) results.push(info);
-	}
-	traverse(node);
-	return results;
-}
-function extractComparisonInfo(node) {
-	if (!isComparisonOperator(node.operatorToken)) return null;
-	const leftNumeric = getStaticNumberValue(node.left) ?? null;
-	const rightNumeric = getStaticNumberValue(node.right) ?? null;
-	if (leftNumeric !== null && rightNumeric !== null || leftNumeric === null && rightNumeric === null) {
-		if (leftNumeric === null && rightNumeric === null) return {
-			direction: getComparisonDirection(node.operatorToken.kind),
-			isStrict: isStrictComparison(node.operatorToken.kind),
-			node,
-			numericValue: null,
-			operatorKind: node.operatorToken.kind,
-			variable: node.left
-		};
-		return null;
-	}
-	if (leftNumeric !== null) return {
-		direction: flipDirection(getComparisonDirection(node.operatorToken.kind)),
-		isStrict: isStrictComparison(node.operatorToken.kind),
-		node,
-		numericValue: leftNumeric,
-		operatorKind: flipOperator(node.operatorToken.kind),
-		variable: node.right
-	};
-	return {
-		direction: getComparisonDirection(node.operatorToken.kind),
-		isStrict: isStrictComparison(node.operatorToken.kind),
-		node,
-		numericValue: rightNumeric,
-		operatorKind: node.operatorToken.kind,
-		variable: node.left
-	};
-}
-function flipDirection(direction) {
-	switch (direction) {
-		case "lower": return "upper";
-		case "upper": return "lower";
-		default: return direction;
-	}
-}
-function flipOperator(operatorKind) {
-	switch (operatorKind) {
-		case SyntaxKind.GreaterThanEqualsToken: return SyntaxKind.LessThanEqualsToken;
-		case SyntaxKind.GreaterThanToken: return SyntaxKind.LessThanToken;
-		case SyntaxKind.LessThanEqualsToken: return SyntaxKind.GreaterThanEqualsToken;
-		case SyntaxKind.LessThanToken: return SyntaxKind.GreaterThanToken;
-		default: return operatorKind;
-	}
-}
-function formatComparison(info, sourceFile) {
-	return info.node.getText(sourceFile);
-}
-function getComparisonDirection(operatorKind) {
-	switch (operatorKind) {
-		case SyntaxKind.EqualsEqualsEqualsToken:
-		case SyntaxKind.EqualsEqualsToken: return "equality";
-		case SyntaxKind.ExclamationEqualsEqualsToken:
-		case SyntaxKind.ExclamationEqualsToken: return "inequality";
-		case SyntaxKind.GreaterThanEqualsToken:
-		case SyntaxKind.GreaterThanToken: return "lower";
-		case SyntaxKind.LessThanEqualsToken:
-		case SyntaxKind.LessThanToken: return "upper";
-		default: return "equality";
-	}
-}
-function getSimplifiedOperator(op1, op2) {
-	const pairs = [
-		[
-			SyntaxKind.EqualsEqualsEqualsToken,
-			SyntaxKind.LessThanToken,
-			"<="
-		],
-		[
-			SyntaxKind.EqualsEqualsToken,
-			SyntaxKind.LessThanToken,
-			"<="
-		],
-		[
-			SyntaxKind.EqualsEqualsEqualsToken,
-			SyntaxKind.GreaterThanToken,
-			">="
-		],
-		[
-			SyntaxKind.EqualsEqualsToken,
-			SyntaxKind.GreaterThanToken,
-			">="
-		]
-	];
-	for (const [a, b, result] of pairs) if (op1 === a && op2 === b || op1 === b && op2 === a) return result;
-	return null;
-}
-function isStrictComparison(operatorKind) {
-	return operatorKind === SyntaxKind.LessThanToken || operatorKind === SyntaxKind.GreaterThanToken;
-}
-var unnecessaryComparisons_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports comparisons that are always true, always false, or can be simplified.",
-		id: "unnecessaryComparisons",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: {
-		impossibleRange: {
-			primary: "This range comparison can never be true.",
-			secondary: ["The upper bound {{ upperBound }} and lower bound {{ lowerBound }} create an impossible range.", "No value can satisfy both conditions simultaneously."],
-			suggestions: ["Check if the comparison operators or values are correct.", "This may indicate swapped values or operators."]
-		},
-		ineffectiveCheck: {
-			primary: "The check `{{ weaker }}` is redundant when `{{ stronger }}` is also checked.",
-			secondary: ["When `{{ stronger }}` is true, `{{ weaker }}` is automatically satisfied."],
-			suggestions: ["Remove the redundant check `{{ weaker }}`."]
-		},
-		redundantComparison: {
-			primary: "This comparison can be simplified to `{{ suggestion }}`.",
-			secondary: ["The combined comparisons are equivalent to a single `{{ suggestion }}` comparison."],
-			suggestions: ["Replace with a single `{{ suggestion }}` comparison for clearer intent."]
-		},
-		selfComparison: {
-			primary: "Comparing a value to itself is unnecessary and likely indicates a logic error.",
-			secondary: ["Self-comparisons always evaluate to the same result for a given operator.", "This pattern often indicates a copy-paste error or typo where different variables were intended."],
-			suggestions: ["Verify that you intended to compare two different values."]
-		}
-	},
-	setup(context) {
-		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
-			if (isComparisonOperator(node.operatorToken) && hasSameTokens(node.left, node.right, sourceFile)) {
-				context.report({
-					message: "selfComparison",
-					range: getTSNodeRange(node, sourceFile)
-				});
-				return;
-			}
-			if (node.operatorToken.kind === SyntaxKind.AmpersandAmpersandToken) {
-				const comparisons = collectComparisonsFromChain(node, SyntaxKind.AmpersandAmpersandToken);
-				if (comparisons.length >= 2) {
-					const impossibleRange = checkImpossibleRange(comparisons, sourceFile);
-					if (impossibleRange) {
-						context.report({
-							data: {
-								lowerBound: formatComparison(impossibleRange.lowerBound, sourceFile),
-								upperBound: formatComparison(impossibleRange.upperBound, sourceFile)
-							},
-							message: "impossibleRange",
-							range: getTSNodeRange(node, sourceFile)
-						});
-						return;
-					}
-					const ineffective = checkIneffectiveChecks(comparisons, sourceFile);
-					if (ineffective) {
-						context.report({
-							data: {
-								stronger: formatComparison(ineffective.stronger, sourceFile),
-								weaker: formatComparison(ineffective.weaker, sourceFile)
-							},
-							message: "ineffectiveCheck",
-							range: getTSNodeRange(ineffective.weaker.node, sourceFile)
-						});
-						return;
-					}
-				}
-			}
-			if (node.operatorToken.kind === SyntaxKind.BarBarToken) {
-				const comparisons = collectComparisonsFromChain(node, SyntaxKind.BarBarToken);
-				if (comparisons.length >= 2) {
-					const redundant = checkRedundantOrComparison(comparisons, sourceFile);
-					if (redundant) {
-						context.report({
-							data: { suggestion: redundant.suggestion },
-							message: "redundantComparison",
-							range: getTSNodeRange(node, sourceFile)
-						});
-						return;
-					}
-				}
-			}
-		} } };
-	}
-});
-//#endregion
-export { unnecessaryComparisons_default as default };

package/lib/rules/unnecessaryConcatenation.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports string concatenation using the + operator when both operands are string literals.";
-    readonly id: "unnecessaryConcatenation";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessaryConcatenation", undefined>;
-export default _default;

package/lib/rules/unnecessaryConcatenation.js

@@ -1,26 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/unnecessaryConcatenation.ts
-var unnecessaryConcatenation_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports string concatenation using the + operator when both operands are string literals.",
-		id: "unnecessaryConcatenation",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { unnecessaryConcatenation: {
-		primary: "This string concatenation can be streamlined into a single string literal.",
-		secondary: ["Concatenating string literals with the + operator is unnecessary and reduces code readability.", "String literals can be combined into a single literal, which is clearer and potentially more performant."],
-		suggestions: ["Combine the string literals into a single string literal."]
-	} },
-	setup(context) {
-		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
-			if (node.operatorToken.kind === SyntaxKind.PlusToken && node.left.kind === SyntaxKind.StringLiteral && node.right.kind === SyntaxKind.StringLiteral) context.report({
-				message: "unnecessaryConcatenation",
-				range: getTSNodeRange(node.operatorToken, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { unnecessaryConcatenation_default as default };

package/lib/rules/unnecessaryEscapes.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports unnecessary escape sequences in string literals and template strings.";
-    readonly id: "unnecessaryEscapes";
-    readonly presets: readonly ["stylistic"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessary", undefined>;
-export default _default;

package/lib/rules/unnecessaryEscapes.js

@@ -1,132 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/unnecessaryEscapes.ts
-const validEscapes = /* @__PURE__ */ new Set([
-	"0",
-	"\"",
-	"'",
-	"\\",
-	"`",
-	"b",
-	"f",
-	"n",
-	"r",
-	"t",
-	"v"
-]);
-function findUnnecessaryEscapes(fullText, quoteCharacter) {
-	const escapes = [];
-	let startIndex = 1;
-	let endIndex = fullText.length - 1;
-	if (quoteCharacter === "`") {
-		if (fullText.endsWith("${")) endIndex = fullText.length - 2;
-		if (fullText.startsWith("}`")) startIndex = 2;
-	}
-	let index = startIndex;
-	while (index < endIndex) {
-		if (fullText[index] !== "\\") {
-			index += 1;
-			continue;
-		}
-		const nextCharacter = fullText[index + 1];
-		if (!nextCharacter || index + 1 >= endIndex) break;
-		if (validEscapes.has(nextCharacter)) {
-			index += 2;
-			continue;
-		}
-		switch (nextCharacter) {
-			case "c": {
-				const characterAfterC = fullText[index + 2];
-				if (characterAfterC && /[a-z]/i.test(characterAfterC)) {
-					index += 3;
-					continue;
-				}
-				break;
-			}
-			case "u": {
-				const afterU = fullText.slice(index + 2);
-				if (/^[\da-f]{4}/i.test(afterU)) {
-					index += 6;
-					continue;
-				}
-				if (afterU.startsWith("{")) {
-					const closeBrace = afterU.indexOf("}");
-					if (closeBrace > 1 && /^[\da-f]+$/i.test(afterU.slice(1, closeBrace))) {
-						index += 3 + closeBrace;
-						continue;
-					}
-				}
-				break;
-			}
-			case "x":
-				if (/^[\da-f]{2}/i.test(fullText.slice(index + 2, index + 4))) {
-					index += 4;
-					continue;
-				}
-				break;
-			default: if (/[1-9]/.test(nextCharacter)) {
-				index += 2;
-				continue;
-			}
-		}
-		if (nextCharacter !== quoteCharacter) escapes.push({
-			character: nextCharacter,
-			end: index + 2,
-			start: index
-		});
-		index += 2;
-	}
-	return escapes;
-}
-var unnecessaryEscapes_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports unnecessary escape sequences in string literals and template strings.",
-		id: "unnecessaryEscapes",
-		presets: ["stylistic"]
-	},
-	messages: { unnecessary: {
-		primary: "Unnecessary escape for character '{{ character }}'.",
-		secondary: ["This character does not require escaping in this context.", "Removing the backslash makes the code clearer without changing its meaning."],
-		suggestions: ["Remove the unnecessary backslash."]
-	} },
-	setup(context) {
-		function checkNode(node, { sourceFile }) {
-			const fullText = node.getText(sourceFile);
-			let quoteChar;
-			if (node.kind === ts.SyntaxKind.StringLiteral) quoteChar = fullText.startsWith("\"") ? "\"" : "'";
-			else quoteChar = "`";
-			const escapes = findUnnecessaryEscapes(fullText, quoteChar);
-			for (const escape of escapes) {
-				const nodeStart = node.getStart(sourceFile);
-				const escapeStart = nodeStart + escape.start;
-				const escapeEnd = nodeStart + escape.end;
-				context.report({
-					data: { character: escape.character },
-					fix: {
-						range: {
-							begin: escapeStart,
-							end: escapeStart + 1
-						},
-						text: ""
-					},
-					message: "unnecessary",
-					range: {
-						begin: escapeStart,
-						end: escapeEnd
-					}
-				});
-			}
-		}
-		return { visitors: {
-			NoSubstitutionTemplateLiteral: checkNode,
-			StringLiteral: checkNode,
-			TemplateExpression: (node, services) => {
-				checkNode(node.head, services);
-				for (const span of node.templateSpans) checkNode(span.literal, services);
-			}
-		} };
-	}
-});
-//#endregion
-export { unnecessaryEscapes_default as default };

package/lib/rules/unnecessaryMathClamps.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports unnecessary Math.min and Math.max calls with constant arguments or incorrect clamping patterns.";
-    readonly id: "unnecessaryMathClamps";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "constantArguments" | "incorrectClampOrder", undefined>;
-export default _default;