@flint.fyi/ts 0.14.6 → 0.18.0

package/lib/rules/unnecessaryCatches.js

@@ -1,68 +1,48 @@
-import * as ts from "typescript";
-import { typescriptLanguage } from "../language.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports catch clauses that only rethrow the caught error without modification.",
-        id: "unnecessaryCatches",
-        preset: "logical",
-    },
-    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) => {
-                    if (!node.variableDeclaration || !ts.isBlock(node.block)) {
-                        return;
-                    }
-                    const statements = node.block.statements;
-                    if (statements.length !== 1) {
-                        return;
-                    }
-                    const statement = statements[0];
-                    if (!ts.isThrowStatement(statement)) {
-                        return;
-                    }
-                    const catchVariable = node.variableDeclaration.name;
-                    const thrownExpression = statement.expression;
-                    if (!ts.isIdentifier(catchVariable) ||
-                        !ts.isIdentifier(thrownExpression)) {
-                        return;
-                    }
-                    if (catchVariable.text !== thrownExpression.text) {
-                        return;
-                    }
-                    const tryStatement = node.parent;
-                    if (!ts.isTryStatement(tryStatement)) {
-                        return;
-                    }
-                    const range = {
-                        begin: node.getStart(context.sourceFile),
-                        end: node.getStart(context.sourceFile) + "catch".length,
-                    };
-                    context.report({
-                        fix: {
-                            range: {
-                                begin: tryStatement.tryBlock.getEnd(),
-                                end: node.getEnd(),
-                            },
-                            text: "",
-                        },
-                        message: "unnecessaryCatch",
-                        range,
-                    });
-                },
-            },
-        };
-    },
+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 };
+
+//# sourceMappingURL=unnecessaryCatches.js.map

package/lib/rules/unnecessaryComparisons.d.ts

@@ -0,0 +1,10 @@
+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: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "impossibleRange" | "ineffectiveCheck" | "redundantComparison" | "selfComparison", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=unnecessaryComparisons.d.ts.map

package/lib/rules/unnecessaryComparisons.js

@@ -0,0 +1,300 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { isComparisonOperator } from "./utils/operators.js";
+import { 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 = extractNumericLiteral(node.left);
+	const rightNumeric = extractNumericLiteral(node.right);
+	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 extractNumericLiteral(node) {
+	const unwrapped = unwrapParenthesizedNode(node);
+	if (unwrapped.kind === SyntaxKind.NumericLiteral) return Number(unwrapped.text);
+	if (unwrapped.kind === SyntaxKind.PrefixUnaryExpression && unwrapped.operator === SyntaxKind.MinusToken && unwrapped.operand.kind === SyntaxKind.NumericLiteral) return -Number(unwrapped.operand.text);
+	if (unwrapped.kind === SyntaxKind.PrefixUnaryExpression && unwrapped.operator === SyntaxKind.PlusToken && unwrapped.operand.kind === SyntaxKind.NumericLiteral) return Number(unwrapped.operand.text);
+	return null;
+}
+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 };
+
+//# sourceMappingURL=unnecessaryComparisons.js.map

package/lib/rules/unnecessaryConcatenation.d.ts

@@ -1,6 +1,10 @@
 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 preset: "stylistic";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "unnecessaryConcatenation", undefined>;
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unnecessaryConcatenation", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
+//# sourceMappingURL=unnecessaryConcatenation.d.ts.map

package/lib/rules/unnecessaryConcatenation.js

@@ -1,38 +1,28 @@
-import * as ts from "typescript";
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports string concatenation using the + operator when both operands are string literals.",
-        id: "unnecessaryConcatenation",
-        preset: "stylistic",
-    },
-    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) => {
-                    if (node.operatorToken.kind === ts.SyntaxKind.PlusToken &&
-                        ts.isStringLiteral(node.left) &&
-                        ts.isStringLiteral(node.right)) {
-                        context.report({
-                            message: "unnecessaryConcatenation",
-                            range: getTSNodeRange(node.operatorToken, context.sourceFile),
-                        });
-                    }
-                },
-            },
-        };
-    },
+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 };
+
+//# sourceMappingURL=unnecessaryConcatenation.js.map

package/lib/rules/unnecessaryEscapes.d.ts

@@ -0,0 +1,10 @@
+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: ["stylistic"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unnecessary", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=unnecessaryEscapes.d.ts.map

package/lib/rules/unnecessaryEscapes.js

@@ -0,0 +1,134 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+//#region src/rules/unnecessaryEscapes.ts
+const validEscapes = 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 };
+
+//# sourceMappingURL=unnecessaryEscapes.js.map

package/lib/rules/unnecessaryMathClamps.d.ts

@@ -0,0 +1,10 @@
+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: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "constantArguments" | "incorrectClampOrder", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=unnecessaryMathClamps.d.ts.map