@flint.fyi/ts 0.15.0 → 0.18.0

package/lib/rules/nullishCheckStyle.js

@@ -0,0 +1,144 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { isNullishLiteral, isUndefinedIdentifier, toEqualityOperator, toLooseOperator, toStrictOperator } from "./utils/equalityOperators.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { isNullKeyword } from "ts-api-utils";
+import { z } from "zod/v4";
+//#region src/rules/nullishCheckStyle.ts
+var nullishCheckStyle_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Enforces consistent equality operator usage when comparing with null or undefined.",
+		id: "nullishCheckStyle"
+	},
+	messages: {
+		preferLooseNull: {
+			primary: "Compare with 'null' rather than 'undefined'.",
+			secondary: ["`x == null` and `x == undefined` are equivalent to each other; both check `x === null || x === undefined`.", "Use `x == null` since it is shorter."],
+			suggestions: ["Replace 'undefined' with 'null'."]
+		},
+		preferLooseNullish: {
+			primary: "Use loose equality ('{{ looseOperator }}') for nullish comparisons.",
+			secondary: ["When checking for nullish values (null or undefined), loose equality is more concise.", "`x == null` checks for both null and undefined, equivalent to `x === null || x === undefined`."],
+			suggestions: ["Replace '{{ strictOperator }}' with '{{ looseOperator }}'."]
+		},
+		preferLooseUndefined: {
+			primary: "Compare with 'undefined' rather than 'null'.",
+			secondary: ["`x == null` and `x == undefined` are equivalent to each other; both check `x === null || x === undefined`.", "Use `x == undefined`."],
+			suggestions: ["Replace 'null' with 'undefined'."]
+		},
+		preferStrictNullish: {
+			primary: "Use strict equality ('{{ strictOperator }}') for nullish comparisons.",
+			secondary: ["When nullish comparison strictness is set to 'strict', use strict equality operators for nullish comparisons."],
+			suggestions: ["Replace '{{ looseOperator }}' with '{{ strictOperator }}'."]
+		}
+	},
+	options: {
+		looseNullishComparisonStyle: z.enum([
+			"prefer-null",
+			"prefer-undefined",
+			"ignore"
+		]).default("prefer-null"),
+		nullishComparisonStrictness: z.enum([
+			"double-equals",
+			"triple-equals",
+			"ignore"
+		]).default("double-equals")
+	},
+	setup(context) {
+		return { visitors: { BinaryExpression: (node, { options, sourceFile }) => {
+			const operator = toEqualityOperator(node.operatorToken.kind);
+			if (operator == null) return;
+			const leftIsNullish = isNullishLiteral(node.left);
+			if (leftIsNullish === isNullishLiteral(node.right)) return;
+			const isLooseComparison = operator === "==" || operator === "!=";
+			if (options.nullishComparisonStrictness === "double-equals" && !isLooseComparison) {
+				const looseOperator = toLooseOperator(operator);
+				const operatorRange = getTSNodeRange(node.operatorToken, sourceFile);
+				context.report({
+					data: {
+						looseOperator,
+						strictOperator: operator
+					},
+					message: "preferLooseNullish",
+					range: leftIsNullish ? {
+						begin: node.left.getStart(sourceFile),
+						end: operatorRange.end
+					} : {
+						begin: operatorRange.begin,
+						end: node.right.getEnd()
+					},
+					suggestions: [{
+						id: "useLooseOperator",
+						range: operatorRange,
+						text: looseOperator
+					}]
+				});
+				return;
+			}
+			if (options.nullishComparisonStrictness === "triple-equals" && isLooseComparison) {
+				const strictOperator = toStrictOperator(operator);
+				const operatorRange = getTSNodeRange(node.operatorToken, sourceFile);
+				context.report({
+					data: {
+						looseOperator: operator,
+						strictOperator
+					},
+					message: "preferStrictNullish",
+					range: leftIsNullish ? {
+						begin: node.left.getStart(sourceFile),
+						end: operatorRange.end
+					} : {
+						begin: operatorRange.begin,
+						end: node.right.getEnd()
+					},
+					suggestions: [{
+						id: "useStrictOperator",
+						range: operatorRange,
+						text: strictOperator
+					}]
+				});
+				return;
+			}
+			if (isLooseComparison) {
+				if (options.looseNullishComparisonStyle === "prefer-null") {
+					const leftIsUndefined = isUndefinedIdentifier(node.left);
+					const rightIsUndefined = isUndefinedIdentifier(node.right);
+					if (leftIsUndefined || rightIsUndefined) context.report({
+						fix: [{
+							range: getTSNodeRange(leftIsUndefined ? node.left : node.right, sourceFile),
+							text: "null"
+						}],
+						message: "preferLooseNull",
+						range: leftIsUndefined ? {
+							begin: node.left.getStart(sourceFile),
+							end: node.operatorToken.getEnd()
+						} : {
+							begin: node.operatorToken.getStart(sourceFile),
+							end: node.right.getEnd()
+						}
+					});
+				} else if (options.looseNullishComparisonStyle === "prefer-undefined") {
+					const leftIsNull = isNullKeyword(node.left);
+					const rightIsNull = isNullKeyword(node.right);
+					if (leftIsNull || rightIsNull) context.report({
+						fix: [{
+							range: getTSNodeRange(leftIsNull ? node.left : node.right, sourceFile),
+							text: "undefined"
+						}],
+						message: "preferLooseUndefined",
+						range: leftIsNull ? {
+							begin: node.left.getStart(sourceFile),
+							end: node.operatorToken.getEnd()
+						} : {
+							begin: node.operatorToken.getStart(sourceFile),
+							end: node.right.getEnd()
+						}
+					});
+				}
+			}
+		} } };
+	}
+});
+//#endregion
+export { nullishCheckStyle_default as default };
+
+//# sourceMappingURL=nullishCheckStyle.js.map

package/lib/rules/nullishCoalescingOperators.d.ts

@@ -0,0 +1,22 @@
+import { z } from "zod/v4";
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Prefer nullish coalescing operator (??) over logical OR (||) for nullish values.";
+    readonly id: "nullishCoalescingOperators";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferNullish" | "preferNullishAssignment" | "preferNullishTernary", {
+    readonly ignoreConditionalTests: z.ZodDefault<z.ZodBoolean>;
+    readonly ignoreIfStatements: z.ZodDefault<z.ZodBoolean>;
+    readonly ignoreMixedLogicalExpressions: z.ZodDefault<z.ZodBoolean>;
+    readonly ignorePrimitives: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodRecord<z.ZodEnum<{
+        string: "string";
+        number: "number";
+        bigint: "bigint";
+        boolean: "boolean";
+    }>, z.ZodBoolean>]>>;
+    readonly ignoreTernaryTests: z.ZodDefault<z.ZodBoolean>;
+}>;
+export default _default;
+//# sourceMappingURL=nullishCoalescingOperators.d.ts.map

package/lib/rules/nullishCoalescingOperators.js

@@ -0,0 +1,311 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, hasSameTokens, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+import * as tsutils from "ts-api-utils";
+import { z } from "zod/v4";
+//#region src/rules/nullishCoalescingOperators.ts
+function analyzeConditionalForNullish(node, sourceFile) {
+	const { condition, whenFalse, whenTrue } = node;
+	if (ts.isIdentifier(condition) && ts.isIdentifier(whenTrue) && condition.text === whenTrue.text) return {
+		alternate: whenFalse,
+		consequent: whenTrue,
+		operator: "",
+		test: condition
+	};
+	if (ts.isPrefixUnaryExpression(condition) && condition.operator === ts.SyntaxKind.ExclamationToken) {
+		const operand = condition.operand;
+		if (ts.isIdentifier(operand) && ts.isIdentifier(whenFalse) && operand.text === whenFalse.text) return {
+			alternate: whenTrue,
+			consequent: whenFalse,
+			operator: "!",
+			test: operand
+		};
+	}
+	if (ts.isBinaryExpression(condition) && isNullLikeComparison(condition)) {
+		const { isNegation, value: testValue } = extractValueFromComparison(condition);
+		if (!testValue) return {};
+		const operator = getComparisonOperator(condition);
+		const [alternate, consequent] = isNegation ? [whenFalse, whenTrue] : [whenTrue, whenFalse];
+		if (!consequentMatchesTest(consequent, testValue, sourceFile)) return {};
+		return {
+			alternate,
+			consequent,
+			operator,
+			test: testValue
+		};
+	}
+	if (ts.isBinaryExpression(condition) && condition.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
+		const leftIsComparison = ts.isBinaryExpression(condition.left) ? isNullLikeComparison(condition.left) : false;
+		const rightIsComparison = ts.isBinaryExpression(condition.right) ? isNullLikeComparison(condition.right) : false;
+		if (leftIsComparison && rightIsComparison) {
+			const leftComp = condition.left;
+			const rightComp = condition.right;
+			const leftValue = extractValueFromComparison(leftComp).value;
+			const rightValue = extractValueFromComparison(rightComp).value;
+			if (leftValue && rightValue && hasSameTokens(leftValue, rightValue, sourceFile)) return {
+				alternate: whenFalse,
+				consequent: whenTrue,
+				operator: "===",
+				test: leftValue
+			};
+		}
+	}
+	if (ts.isBinaryExpression(condition) && condition.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
+		const leftIsComparison = ts.isBinaryExpression(condition.left) ? isNullLikeComparison(condition.left) : false;
+		const rightIsComparison = ts.isBinaryExpression(condition.right) ? isNullLikeComparison(condition.right) : false;
+		if (leftIsComparison && rightIsComparison) {
+			const leftComp = condition.left;
+			const rightComp = condition.right;
+			const leftValue = extractValueFromComparison(leftComp).value;
+			const rightValue = extractValueFromComparison(rightComp).value;
+			if (leftValue && rightValue && hasSameTokens(leftValue, rightValue, sourceFile)) return {
+				alternate: whenTrue,
+				consequent: whenFalse,
+				operator: "===",
+				test: leftValue
+			};
+		}
+	}
+	return {};
+}
+function consequentMatchesTest(consequent, test, sourceFile) {
+	if (hasSameTokens(consequent, test, sourceFile)) return true;
+	if (ts.isPropertyAccessExpression(consequent) || ts.isElementAccessExpression(consequent) || ts.isCallExpression(consequent)) return consequentMatchesTest(consequent.expression, test, sourceFile);
+	return false;
+}
+function extractAssignmentFromIfStatement(node) {
+	let assignmentExpr;
+	if (ts.isBlock(node.thenStatement)) {
+		if (node.thenStatement.statements.length === 1) {
+			const stmt = node.thenStatement.statements[0];
+			if (stmt && ts.isExpressionStatement(stmt)) assignmentExpr = stmt.expression;
+		}
+	} else if (ts.isExpressionStatement(node.thenStatement)) assignmentExpr = node.thenStatement.expression;
+	if (!assignmentExpr || !ts.isBinaryExpression(assignmentExpr) || assignmentExpr.operatorToken.kind !== ts.SyntaxKind.EqualsToken) return;
+	return {
+		left: assignmentExpr.left,
+		right: assignmentExpr.right
+	};
+}
+function extractValueFromComparison(node) {
+	const isNegation = node.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsToken || node.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken;
+	if (isNullLike(node.left)) return {
+		isNegation,
+		value: node.right
+	};
+	if (isNullLike(node.right)) return {
+		isNegation,
+		value: node.left
+	};
+	return {
+		isNegation,
+		value: null
+	};
+}
+function getComparisonOperator(node) {
+	switch (node.operatorToken.kind) {
+		case ts.SyntaxKind.EqualsEqualsEqualsToken: return "===";
+		case ts.SyntaxKind.EqualsEqualsToken: return "==";
+		case ts.SyntaxKind.ExclamationEqualsEqualsToken: return "!==";
+		case ts.SyntaxKind.ExclamationEqualsToken: return "!=";
+		default: return "";
+	}
+}
+function getTypeFlags(type) {
+	let flags = 0;
+	for (const constituent of tsutils.unionConstituents(type)) for (const subConstituent of tsutils.intersectionConstituents(constituent)) flags |= subConstituent.getFlags();
+	return flags;
+}
+function isConditionalTest(node) {
+	switch (node.parent.kind) {
+		case ts.SyntaxKind.BinaryExpression:
+			if (node.parent.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken || node.parent.operatorToken.kind === ts.SyntaxKind.BarBarToken) return isConditionalTest(node.parent);
+			return false;
+		case ts.SyntaxKind.ConditionalExpression: return node.parent.condition === node || isConditionalTest(node.parent);
+		case ts.SyntaxKind.DoStatement:
+		case ts.SyntaxKind.IfStatement:
+		case ts.SyntaxKind.WhileStatement: return node.parent.expression === node;
+		case ts.SyntaxKind.ForStatement: return node.parent.condition === node;
+		case ts.SyntaxKind.PrefixUnaryExpression: return node.parent.operator === ts.SyntaxKind.ExclamationToken && isConditionalTest(node.parent);
+		default: return false;
+	}
+}
+function isFalsyLiteralType(part) {
+	if (part.isNumberLiteral() && part.value === 0) return true;
+	if (part.isStringLiteral() && part.value === "") return true;
+	const flags = part.getFlags();
+	if (flags & ts.TypeFlags.BooleanLiteral) {
+		if (part.intrinsicName === "false") return true;
+	}
+	if (flags & ts.TypeFlags.BigIntLiteral) {
+		const value = part.value;
+		if (!value.negative && value.base10Value === "0") return true;
+	}
+	return false;
+}
+function isIfStatementNullishCheck(node) {
+	switch (node.expression.kind) {
+		case ts.SyntaxKind.BinaryExpression: return isNullLikeComparison(node.expression);
+		case ts.SyntaxKind.PrefixUnaryExpression: return node.expression.operator === ts.SyntaxKind.ExclamationToken;
+		default: return false;
+	}
+}
+function isMixedLogicalExpression(node) {
+	const seen = /* @__PURE__ */ new Set();
+	const queue = [
+		node.parent,
+		node.left,
+		node.right
+	];
+	for (const current of queue) {
+		if (!seen.has(current)) continue;
+		seen.add(current);
+		if (ts.isBinaryExpression(current)) {
+			if (current.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) return true;
+			if (current.operatorToken.kind === ts.SyntaxKind.BarBarToken || current.operatorToken.kind === ts.SyntaxKind.BarBarEqualsToken) queue.push(current.parent, current.left, current.right);
+		}
+	}
+	return false;
+}
+function isNullishType(type) {
+	return tsutils.isTypeFlagSet(type, ts.TypeFlags.Null | ts.TypeFlags.Undefined);
+}
+function isNullLike(node) {
+	switch (node.kind) {
+		case ts.SyntaxKind.Identifier: return node.text === "undefined";
+		case ts.SyntaxKind.NullKeyword: return true;
+		default: return false;
+	}
+}
+function isNullLikeComparison(node) {
+	return (node.operatorToken.kind === ts.SyntaxKind.EqualsEqualsToken || node.operatorToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken || node.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsToken || node.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken) && (isNullLike(node.left) || isNullLike(node.right));
+}
+function isTypeEligibleForPreferNullish(type, ignorePrimitives) {
+	if (!typeCanBeNullish(type) || tsutils.isTypeFlagSet(type, ts.TypeFlags.Any | ts.TypeFlags.Unknown) || !ignorePrimitives) return true;
+	const ignorableFlags = [
+		(ignorePrimitives === true || typeof ignorePrimitives === "object" && ignorePrimitives.bigint) && ts.TypeFlags.BigIntLike,
+		(ignorePrimitives === true || typeof ignorePrimitives === "object" && ignorePrimitives.boolean) && ts.TypeFlags.BooleanLike,
+		(ignorePrimitives === true || typeof ignorePrimitives === "object" && ignorePrimitives.number) && ts.TypeFlags.NumberLike,
+		(ignorePrimitives === true || typeof ignorePrimitives === "object" && ignorePrimitives.string) && ts.TypeFlags.StringLike
+	].filter((flag) => typeof flag === "number").reduce((previous, flag) => previous | flag, 0);
+	return ignorableFlags === 0 || !(getTypeFlags(type) & ignorableFlags);
+}
+function shouldIgnoreNode(node, ignorePrimitives, typeChecker) {
+	const type = typeChecker.getTypeAtLocation(node);
+	return tsutils.isTypeFlagSet(type, ts.TypeFlags.Any | ts.TypeFlags.Unknown) || !typeCanBeNullish(type) || typeHasNonNullishFalsyValues(type) || !isTypeEligibleForPreferNullish(type, ignorePrimitives);
+}
+function typeCanBeNullish(type) {
+	return tsutils.unionConstituents(type).some(isNullishType);
+}
+function typeHasNonNullishFalsyValues(type) {
+	return tsutils.unionConstituents(type).some((constituent) => isFalsyLiteralType(constituent) || constituent.getFlags() & (ts.TypeFlags.String | ts.TypeFlags.Number | ts.TypeFlags.BigInt | ts.TypeFlags.Boolean));
+}
+var nullishCoalescingOperators_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Prefer nullish coalescing operator (??) over logical OR (||) for nullish values.",
+		id: "nullishCoalescingOperators",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: {
+		preferNullish: {
+			primary: "Prefer nullish coalescing operator (`??`) over logical OR (`||`) for nullish checks.",
+			secondary: ["The `||` operator returns the right operand for any falsy value (empty string, 0, false, null, undefined).", "The `??` operator only returns the right operand for null or undefined, preserving other falsy values."],
+			suggestions: ["Replace `||` with `??`."]
+		},
+		preferNullishAssignment: {
+			primary: "Prefer nullish coalescing assignment (`??=`) over assignment with null/undefined check.",
+			secondary: [],
+			suggestions: ["Replace with nullish coalescing assignment."]
+		},
+		preferNullishTernary: {
+			primary: "Prefer nullish coalescing operator (`??`) over ternary expression for nullish checks.",
+			secondary: [],
+			suggestions: ["Replace with nullish coalescing."]
+		}
+	},
+	options: {
+		ignoreConditionalTests: z.boolean().default(true).describe("Whether to skip cases where the expression is in a conditional context."),
+		ignoreIfStatements: z.boolean().default(false).describe("Whether to skip if statement patterns with nullish checks."),
+		ignoreMixedLogicalExpressions: z.boolean().default(false).describe("Whether to skip expressions that mix && and || operators."),
+		ignorePrimitives: z.union([z.boolean(), z.record(z.enum([
+			"bigint",
+			"boolean",
+			"number",
+			"string"
+		]), z.boolean())]).default({
+			bigint: false,
+			boolean: false,
+			number: false,
+			string: false
+		}).describe("Whether to skip primitive types. Can be a boolean or an object with per-type configuration."),
+		ignoreTernaryTests: z.boolean().default(false).describe("Whether to skip ternary expressions.")
+	},
+	setup(context) {
+		function getOptionalChainInsertPosition(node, test, sourceFile) {
+			if (node.kind === ts.SyntaxKind.PropertyAccessExpression || node.kind === ts.SyntaxKind.ElementAccessExpression) {
+				if (hasSameTokens(node.expression, test, sourceFile)) return {
+					needsDot: ts.isElementAccessExpression(node),
+					pos: node.expression.getEnd()
+				};
+				return getOptionalChainInsertPosition(node.expression, test, sourceFile);
+			}
+			if (ts.isCallExpression(node)) return getOptionalChainInsertPosition(node.expression, test, sourceFile);
+		}
+		function createNullishNodesFix(consequent, alternate, sourceFile, range, test) {
+			const getText = (node) => sourceFile.text.substring(node.getStart(sourceFile), node.getEnd());
+			let leftText = getText(consequent);
+			if (test && test !== consequent) {
+				const insert = getOptionalChainInsertPosition(consequent, test, sourceFile);
+				if (insert) {
+					const offset = insert.pos - consequent.getStart(sourceFile);
+					leftText = leftText.slice(0, offset) + (insert.needsDot ? "?." : "?") + leftText.slice(offset);
+				}
+			}
+			return {
+				range,
+				text: `${leftText} ?? ${getText(alternate)}`
+			};
+		}
+		return { visitors: {
+			BinaryExpression: (node, { options, sourceFile, typeChecker }) => {
+				if (options.ignoreConditionalTests && isConditionalTest(node) || options.ignoreMixedLogicalExpressions && isMixedLogicalExpression(node) || ![ts.SyntaxKind.BarBarEqualsToken, ts.SyntaxKind.BarBarToken].includes(node.operatorToken.kind) || shouldIgnoreNode(node.left, options.ignorePrimitives, typeChecker)) return;
+				const range = getTSNodeRange(node.operatorToken, sourceFile);
+				const fullRange = getTSNodeRange(node, sourceFile);
+				context.report({
+					fix: {
+						range,
+						text: node.operatorToken.kind === ts.SyntaxKind.BarBarToken ? "??" : "??="
+					},
+					message: "preferNullish",
+					range: fullRange
+				});
+			},
+			ConditionalExpression: (node, { options, sourceFile, typeChecker }) => {
+				if (options.ignoreTernaryTests || options.ignoreConditionalTests && isConditionalTest(node)) return;
+				const { alternate, consequent, test } = analyzeConditionalForNullish(node, sourceFile);
+				if (!test || !consequent || !alternate || shouldIgnoreNode(test, options.ignorePrimitives, typeChecker)) return;
+				const range = getTSNodeRange(node, sourceFile);
+				context.report({
+					fix: createNullishNodesFix(consequent, alternate, sourceFile, range, test),
+					message: "preferNullishTernary",
+					range
+				});
+			},
+			IfStatement: (node, { options, sourceFile, typeChecker }) => {
+				if (options.ignoreIfStatements || node.elseStatement || !isIfStatementNullishCheck(node)) return;
+				const assignmentExpression = extractAssignmentFromIfStatement(node);
+				if (!assignmentExpression || shouldIgnoreNode(assignmentExpression.left, options.ignorePrimitives, typeChecker)) return;
+				const range = getTSNodeRange(node, sourceFile);
+				context.report({
+					fix: createNullishNodesFix(assignmentExpression.left, assignmentExpression.right, sourceFile, range),
+					message: "preferNullishAssignment",
+					range
+				});
+			}
+		} };
+	}
+});
+//#endregion
+export { nullishCoalescingOperators_default as default };
+
+//# sourceMappingURL=nullishCoalescingOperators.js.map

package/lib/rules/numberMethodRanges.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports when number method arguments are outside their valid range.";
+    readonly id: "numberMethodRanges";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "outOfRange", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=numberMethodRanges.d.ts.map

package/lib/rules/numberMethodRanges.js

@@ -0,0 +1,74 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/numberMethodRanges.ts
+const methodSpecs = new Map([
+	["toExponential", {
+		max: 100,
+		min: 0,
+		name: "toExponential"
+	}],
+	["toFixed", {
+		max: 100,
+		min: 0,
+		name: "toFixed"
+	}],
+	["toPrecision", {
+		max: 100,
+		min: 1,
+		name: "toPrecision"
+	}],
+	["toString", {
+		max: 36,
+		min: 2,
+		name: "toString"
+	}]
+]);
+function getMethodName(expression) {
+	if (expression.kind === SyntaxKind.PropertyAccessExpression && expression.name.kind === SyntaxKind.Identifier) return expression.name.text;
+	if (expression.kind === SyntaxKind.ElementAccessExpression && expression.argumentExpression.kind === SyntaxKind.StringLiteral) return expression.argumentExpression.text;
+}
+function getNumericValue(node) {
+	if (node.kind === SyntaxKind.NumericLiteral) return Number(node.text);
+	if (node.kind === SyntaxKind.PrefixUnaryExpression && node.operator === SyntaxKind.MinusToken && node.operand.kind === SyntaxKind.NumericLiteral) return -Number(node.operand.text);
+}
+var numberMethodRanges_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports when number method arguments are outside their valid range.",
+		id: "numberMethodRanges",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { outOfRange: {
+		primary: "The argument `{{ value }}` is out of range for `{{ method }}`. Use a value between {{ min }} and {{ max }}.",
+		secondary: ["Passing an out-of-range argument to `{{ method }}` will throw a RangeError at runtime."],
+		suggestions: ["Check the documentation for `{{ method }}` to see the valid range of values."]
+	} },
+	setup(context) {
+		return { visitors: { CallExpression: (node, { sourceFile }) => {
+			if (!node.arguments.length) return;
+			const methodName = getMethodName(node.expression);
+			if (!methodName) return;
+			const spec = methodSpecs.get(methodName);
+			if (!spec) return;
+			const argument = node.arguments[0];
+			if (argument.kind === SyntaxKind.SpreadElement) return;
+			const value = getNumericValue(argument);
+			if (value === void 0) return;
+			if (Number.isInteger(value) && value >= spec.min && value <= spec.max) return;
+			context.report({
+				data: {
+					max: String(spec.max),
+					method: spec.name,
+					min: String(spec.min),
+					value: String(value)
+				},
+				message: "outOfRange",
+				range: getTSNodeRange(argument, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+export { numberMethodRanges_default as default };
+
+//# sourceMappingURL=numberMethodRanges.js.map

package/lib/rules/numberStaticMethods.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using legacy global functions instead of `Number` static methods.";
+    readonly id: "numberStaticMethods";
+    readonly presets: ["logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferNumberMethod", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=numberStaticMethods.d.ts.map

package/lib/rules/numberStaticMethods.js

@@ -0,0 +1,53 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, isGlobalVariable, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+//#region src/rules/numberStaticMethods.ts
+const globalReplacements = new Map([["isFinite", "Number.isFinite"], ["isNaN", "Number.isNaN"]]);
+function isDeclarationName(node) {
+	return ts.isFunctionDeclaration(node.parent) && node.parent.name === node || ts.isVariableDeclaration(node.parent) && node.parent.name === node || ts.isParameter(node.parent) && node.parent.name === node;
+}
+function isLeftHandSide(node) {
+	return node.parent.kind === ts.SyntaxKind.BinaryExpression && ts.isBinaryExpression(node.parent) && node.parent.left === node && node.parent.operatorToken.kind >= ts.SyntaxKind.FirstAssignment && node.parent.operatorToken.kind <= ts.SyntaxKind.LastAssignment;
+}
+function isPropertyAccessOfNode(node) {
+	return ts.isPropertyAccessExpression(node.parent) && node.parent.name === node;
+}
+function isPropertyShorthandOfNode(node) {
+	return ts.isShorthandPropertyAssignment(node.parent) && node.parent.name === node;
+}
+var numberStaticMethods_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports using legacy global functions instead of `Number` static methods.",
+		id: "numberStaticMethods",
+		presets: ["logicalStrict"]
+	},
+	messages: { preferNumberMethod: {
+		primary: "Prefer the more precise `{{ replacement }}` over the legacy global `{{ name }}`.",
+		secondary: ["`Number` static methods clearly indicate you're working with numbers.", "The global methods like `isFinite` and `isNaN` coerce their arguments, which can lead to unexpected behavior."],
+		suggestions: ["Replace `{{ name }}` with `{{ replacement }}`."]
+	} },
+	setup(context) {
+		return { visitors: { Identifier: (node, { sourceFile, typeChecker }) => {
+			const replacement = globalReplacements.get(node.text);
+			if (!replacement || isPropertyAccessOfNode(node) || isPropertyShorthandOfNode(node) || isDeclarationName(node) || !isGlobalVariable(node, typeChecker) || isLeftHandSide(node)) return;
+			const range = getTSNodeRange(node, sourceFile);
+			context.report({
+				data: {
+					name: node.text,
+					replacement
+				},
+				message: "preferNumberMethod",
+				range,
+				suggestions: [{
+					id: "replaceWithNumberMethod",
+					range,
+					text: replacement
+				}]
+			});
+		} } };
+	}
+});
+//#endregion
+export { numberStaticMethods_default as default };
+
+//# sourceMappingURL=numberStaticMethods.js.map

package/lib/rules/numericErasingOperations.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports operations that always result in zero, such as multiplication by zero.";
+    readonly id: "numericErasingOperations";
+    readonly presets: ["logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "erasingOperation", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=numericErasingOperations.d.ts.map