@flint.fyi/ts 0.21.0 → 0.22.0

package/lib/rules/multilineAmbiguities.js

@@ -1,62 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/multilineAmbiguities.ts
-var multilineAmbiguities_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports ambiguous multiline expressions that could be misinterpreted.",
-		id: "multilineAmbiguities",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { ambiguity: {
-		primary: "This ambiguous line break before {{ after }} will be misinterpreted as a {{ interpretation }}.",
-		secondary: ["When a line ends with an expression and the next line starts with {{ after }}, it may be interpreted as a {{ interpretation }} instead of two separate statements.", "This can lead to unexpected behavior and runtime errors that are difficult to debug."],
-		suggestions: ["Add a semicolon after the first line to make it clear they are separate statements.", "Alternatively, move the {{ after }} to the same line as the first expression if a {{ interpretation }} is intended."]
-	} },
-	setup(context) {
-		function checkMultilineDelimiter(expressionEnd, delimiterStart, after, interpretation, sourceFile) {
-			const { line: expressionEndLine } = sourceFile.getLineAndCharacterOfPosition(expressionEnd);
-			const { line: delimiterLine } = sourceFile.getLineAndCharacterOfPosition(delimiterStart);
-			if (expressionEndLine < delimiterLine) context.report({
-				data: {
-					after,
-					interpretation
-				},
-				message: "ambiguity",
-				range: {
-					begin: delimiterStart,
-					end: getLineEndPosition(delimiterLine, sourceFile)
-				}
-			});
-		}
-		return { visitors: {
-			CallExpression: (node, { sourceFile }) => {
-				if (!node.arguments.length || node.questionDotToken) return;
-				const openParen = findChildToken(node, ts$1.SyntaxKind.OpenParenToken, sourceFile);
-				if (!openParen) return;
-				checkMultilineDelimiter(getExpressionEnd(node, sourceFile), openParen.getStart(sourceFile), "parentheses", "function call", sourceFile);
-			},
-			ElementAccessExpression: (node, { sourceFile }) => {
-				if (node.questionDotToken) return;
-				const openBracket = findChildToken(node, ts$1.SyntaxKind.OpenBracketToken, sourceFile);
-				if (!openBracket) return;
-				checkMultilineDelimiter(node.expression.getEnd(), openBracket.getStart(sourceFile), "brackets", "property access", sourceFile);
-			},
-			TaggedTemplateExpression: (node, { sourceFile }) => {
-				checkMultilineDelimiter(node.tag.getEnd(), node.template.getStart(sourceFile), "a template literal", "tagged template", sourceFile);
-			}
-		} };
-	}
-});
-function findChildToken(node, kind, sourceFile) {
-	for (const child of node.getChildren(sourceFile)) if (child.kind === kind) return child;
-}
-function getExpressionEnd(node, sourceFile) {
-	return (node.typeArguments && findChildToken(node, ts$1.SyntaxKind.GreaterThanToken, sourceFile))?.getEnd() ?? node.expression.getEnd();
-}
-function getLineEndPosition(lineNumber, sourceFile) {
-	const nextLineStart = sourceFile.getLineStarts()[lineNumber + 1];
-	return nextLineStart === void 0 ? sourceFile.getEnd() : nextLineStart - 1;
-}
-//#endregion
-export { multilineAmbiguities_default as default };

package/lib/rules/namedDefaultExports.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports anonymous functions and classes as the default export.";
-    readonly id: "namedDefaultExports";
-    readonly presets: readonly ["stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "anonymousClass" | "anonymousFunction", undefined>;
-export default _default;

package/lib/rules/namedDefaultExports.js

@@ -1,58 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts, { SyntaxKind } from "typescript";
-//#region src/rules/namedDefaultExports.ts
-function hasDefaultModifier(modifiers) {
-	return modifiers?.some((mod) => mod.kind === SyntaxKind.DefaultKeyword);
-}
-function hasExportModifier(modifiers) {
-	return modifiers?.some((mod) => mod.kind === SyntaxKind.ExportKeyword);
-}
-var namedDefaultExports_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports anonymous functions and classes as the default export.",
-		id: "namedDefaultExports",
-		presets: ["stylisticStrict"]
-	},
-	messages: {
-		anonymousClass: {
-			primary: "This default-exported class is missing an informative name.",
-			secondary: ["Named default exports improve codebase searchability by ensuring consistent identifier use for a module's default export.", "When a class is anonymous, it becomes harder to find all usages and references in the codebase."],
-			suggestions: ["Add a name to the exported class."]
-		},
-		anonymousFunction: {
-			primary: "This default-exported function is missing an informative name.",
-			secondary: ["Named default exports improve codebase searchability by ensuring consistent identifier use for a module's default export.", "When a function is anonymous, it becomes harder to find all usages and references in the codebase."],
-			suggestions: ["Add a name to the exported function.", "Assign the arrow function to a named variable, then export it."]
-		}
-	},
-	setup(context) {
-		return { visitors: {
-			ClassDeclaration: (node, { sourceFile }) => {
-				if (hasExportModifier(node.modifiers) && hasDefaultModifier(node.modifiers) && !node.name) context.report({
-					message: "anonymousClass",
-					range: getTSNodeRange(node, sourceFile)
-				});
-			},
-			ExportAssignment: (node, { sourceFile }) => {
-				if (node.isExportEquals) return;
-				if (ts.isArrowFunction(node.expression) || ts.isFunctionExpression(node.expression) && !node.expression.name) context.report({
-					message: "anonymousFunction",
-					range: getTSNodeRange(node.expression, sourceFile)
-				});
-				else if (ts.isClassExpression(node.expression) && !node.expression.name) context.report({
-					message: "anonymousClass",
-					range: getTSNodeRange(node.expression, sourceFile)
-				});
-			},
-			FunctionDeclaration: (node, { sourceFile }) => {
-				if (hasExportModifier(node.modifiers) && hasDefaultModifier(node.modifiers) && !node.name) context.report({
-					message: "anonymousFunction",
-					range: getTSNodeRange(node, sourceFile)
-				});
-			}
-		} };
-	}
-});
-//#endregion
-export { namedDefaultExports_default as default };

package/lib/rules/namespaceDeclarations.d.ts

@@ -1,13 +0,0 @@
-import { z } from "zod/v4";
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using legacy `namespace` declarations.";
-    readonly id: "namespaceDeclarations";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferModules", {
-    allowDeclarations: z.ZodDefault<z.ZodBoolean>;
-    allowDefinitionFiles: z.ZodDefault<z.ZodBoolean>;
-}>;
-export default _default;

package/lib/rules/namespaceDeclarations.js

@@ -1,35 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-import * as tsutils from "ts-api-utils";
-import { z as z$1 } from "zod/v4";
-//#region src/rules/namespaceDeclarations.ts
-var namespaceDeclarations_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using legacy `namespace` declarations.",
-		id: "namespaceDeclarations",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { preferModules: {
-		primary: "Prefer using ECMAScript modules over legacy TypeScript namespaces.",
-		secondary: ["Namespaces are a legacy feature of TypeScript that can lead to confusion and are not compatible with ECMAScript modules."],
-		suggestions: ["Modern codebases generally use `export` and `import` statements to define and use ECMAScript modules instead."]
-	} },
-	options: {
-		allowDeclarations: z$1.boolean().default(false).describe("Whether to allow namespaces declared with the `declare` keyword."),
-		allowDefinitionFiles: z$1.boolean().default(false).describe("Whether to allow namespaces in `.d.ts` and other definition files.")
-	},
-	setup(context) {
-		return { visitors: { ModuleDeclaration: (node, { options: { allowDeclarations, allowDefinitionFiles }, sourceFile }) => {
-			if (allowDefinitionFiles && sourceFile.isDeclarationFile) return;
-			if (node.parent.kind !== SyntaxKind.SourceFile || node.name.kind !== SyntaxKind.Identifier || node.name.text === "global") return;
-			if (allowDeclarations && tsutils.includesModifier(node.modifiers, SyntaxKind.DeclareKeyword)) return;
-			context.report({
-				message: "preferModules",
-				range: getTSNodeRange(node.getChildAt(0), sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { namespaceDeclarations_default as default };

package/lib/rules/namespaceImplicitAmbientImports.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports declared namespaces that implicitly export all members.";
-    readonly id: "namespaceImplicitAmbientImports";
-    readonly presets: readonly ["stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "implicitExports", undefined>;
-export default _default;

package/lib/rules/namespaceImplicitAmbientImports.js

@@ -1,38 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts, { SyntaxKind } from "typescript";
-//#region src/rules/namespaceImplicitAmbientImports.ts
-function hasExportModifier(node) {
-	return !!(ts.canHaveModifiers(node) && ts.getModifiers(node)?.some((modifier) => modifier.kind === SyntaxKind.ExportKeyword));
-}
-function hasNamedExport(statements) {
-	return statements.some((statement) => statement.kind === SyntaxKind.ExportDeclaration && statement.exportClause?.kind === SyntaxKind.NamedExports);
-}
-function hasNonExportedMember(statements) {
-	return statements.some((statement) => !hasExportModifier(statement) && (statement.kind === SyntaxKind.TypeAliasDeclaration || statement.kind === SyntaxKind.InterfaceDeclaration || statement.kind === SyntaxKind.ClassDeclaration || statement.kind === SyntaxKind.EnumDeclaration || statement.kind === SyntaxKind.FunctionDeclaration || statement.kind === SyntaxKind.VariableStatement || statement.kind === SyntaxKind.ModuleDeclaration));
-}
-var namespaceImplicitAmbientImports_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports declared namespaces that implicitly export all members.",
-		id: "namespaceImplicitAmbientImports",
-		presets: ["stylisticStrict"]
-	},
-	messages: { implicitExports: {
-		primary: "Declared namespaces without explicit exports implicitly export all members.",
-		secondary: ["When a declared namespace has no named export statements, all its members are implicitly exported.", "This can lead to unintended exports and make it harder to understand what the namespace exposes."],
-		suggestions: ["Add an `export {};` statement to opt out of implicit exports, then explicitly export the members you intend to expose."]
-	} },
-	setup(context) {
-		return { visitors: { ModuleDeclaration: (node, { sourceFile }) => {
-			if (!node.modifiers?.some((modifier) => modifier.kind === SyntaxKind.DeclareKeyword) || node.name.kind !== SyntaxKind.Identifier || node.body?.kind !== SyntaxKind.ModuleBlock) return;
-			const statements = node.body.statements;
-			if (!statements.length || hasNamedExport(statements) || !hasNonExportedMember(statements)) return;
-			context.report({
-				message: "implicitExports",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { namespaceImplicitAmbientImports_default as default };

package/lib/rules/namespaceKeywords.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using `module` keyword instead of `namespace` for TypeScript namespaces.";
-    readonly id: "namespaceKeywords";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferNamespace", undefined>;
-export default _default;

package/lib/rules/namespaceKeywords.js

@@ -1,38 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/namespaceKeywords.ts
-var namespaceKeywords_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using `module` keyword instead of `namespace` for TypeScript namespaces.",
-		id: "namespaceKeywords",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { preferNamespace: {
-		primary: "The `namespace` keyword is preferred over `module` for TypeScript namespaces.",
-		secondary: [
-			"TypeScript originally used the `module` keyword to declare internal modules (namespaces).",
-			"The `namespace` keyword was later introduced to avoid confusion with ES6 modules.",
-			"Using `namespace` makes it clear you are defining a TypeScript namespace, not an ES6 module."
-		],
-		suggestions: ["Replace `module` with `namespace`."]
-	} },
-	setup(context) {
-		return { visitors: { ModuleDeclaration: (node, { sourceFile }) => {
-			if (node.name.kind === SyntaxKind.StringLiteral) return;
-			const moduleKeywordToken = node.getChildren(sourceFile).find((child) => child.kind === SyntaxKind.ModuleKeyword);
-			if (!moduleKeywordToken) return;
-			const range = getTSNodeRange(moduleKeywordToken, sourceFile);
-			context.report({
-				fix: {
-					range,
-					text: "namespace"
-				},
-				message: "preferNamespace",
-				range
-			});
-		} } };
-	}
-});
-//#endregion
-export { namespaceKeywords_default as default };

package/lib/rules/nativeObjectExtensions.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports extending the prototype of native JavaScript objects.";
-    readonly id: "nativeObjectExtensions";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noExtendNative", undefined>;
-export default _default;

package/lib/rules/nativeObjectExtensions.js

@@ -1,112 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/nativeObjectExtensions.ts
-const nativeConstructors = /* @__PURE__ */ new Set([
-	"AggregateError",
-	"Array",
-	"ArrayBuffer",
-	"BigInt",
-	"BigInt64Array",
-	"BigUint64Array",
-	"Boolean",
-	"DataView",
-	"Date",
-	"Error",
-	"EvalError",
-	"FinalizationRegistry",
-	"Float16Array",
-	"Float32Array",
-	"Float64Array",
-	"Function",
-	"Int8Array",
-	"Int16Array",
-	"Int32Array",
-	"Map",
-	"Number",
-	"Object",
-	"Promise",
-	"RangeError",
-	"ReferenceError",
-	"RegExp",
-	"Set",
-	"SharedArrayBuffer",
-	"String",
-	"Symbol",
-	"SyntaxError",
-	"TypeError",
-	"Uint8Array",
-	"Uint8ClampedArray",
-	"Uint16Array",
-	"Uint32Array",
-	"URIError",
-	"WeakMap",
-	"WeakRef",
-	"WeakSet"
-]);
-function getPrototypeObject(node) {
-	return ts$1.isIdentifier(node.expression) && node.expression;
-}
-function isPrototypeAccess(node) {
-	switch (node.kind) {
-		case ts$1.SyntaxKind.ElementAccessExpression: return ts$1.isStringLiteral(node.argumentExpression) && node.argumentExpression.text === "prototype";
-		case ts$1.SyntaxKind.PropertyAccessExpression: return node.name.text === "prototype";
-		default: return false;
-	}
-}
-var nativeObjectExtensions_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports extending the prototype of native JavaScript objects.",
-		id: "nativeObjectExtensions",
-		presets: ["javascript"]
-	},
-	messages: { noExtendNative: {
-		primary: "Extending the {{ name }} prototype modifies built-in behavior that other code depends on.",
-		secondary: [
-			"Adding properties to native prototypes affects all instances of that type across the codebase.",
-			"This can cause conflicts with other libraries that expect standard prototype behavior.",
-			"Future ECMAScript versions may add methods with the same name, causing unexpected behavior."
-		],
-		suggestions: ["Create a wrapper class or utility function instead of extending the prototype.", "Use composition rather than modifying the prototype chain."]
-	} },
-	setup(context) {
-		function checkNode(node, { program, sourceFile, typeChecker }) {
-			if (!isPrototypeAccess(node)) return;
-			const objectIdentifier = getPrototypeObject(node);
-			if (!objectIdentifier) return;
-			const name = objectIdentifier.text;
-			if (!nativeConstructors.has(name) || !isGlobalDeclarationOfName(objectIdentifier, name, typeChecker, program)) return;
-			switch (node.parent.kind) {
-				case ts$1.SyntaxKind.CallExpression: {
-					if (node.parent.arguments[0] !== node) break;
-					const callee = node.parent.expression;
-					if (!ts$1.isPropertyAccessExpression(callee) || !ts$1.isIdentifier(callee.expression) || callee.expression.text !== "Object" || callee.name.text !== "defineProperty" && callee.name.text !== "defineProperties" || !isGlobalDeclarationOfName(callee.expression, "Object", typeChecker, program)) break;
-					context.report({
-						data: { name },
-						message: "noExtendNative",
-						range: getTSNodeRange(node.parent, sourceFile)
-					});
-					break;
-				}
-				case ts$1.SyntaxKind.ElementAccessExpression:
-				case ts$1.SyntaxKind.PropertyAccessExpression: {
-					if (node.parent.expression !== node) break;
-					const grandparent = node.parent.parent;
-					if (!ts$1.isBinaryExpression(grandparent) || grandparent.operatorToken.kind !== ts$1.SyntaxKind.EqualsToken || grandparent.left !== node.parent) break;
-					context.report({
-						data: { name },
-						message: "noExtendNative",
-						range: getTSNodeRange(grandparent, sourceFile)
-					});
-					break;
-				}
-			}
-		}
-		return { visitors: {
-			ElementAccessExpression: checkNode,
-			PropertyAccessExpression: checkNode
-		} };
-	}
-});
-//#endregion
-export { nativeObjectExtensions_default as default };

package/lib/rules/negativeIndexLengthMethods.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Prefer negative index over `.length - index` for `at`, `slice`, `splice`, and similar methods.";
-    readonly id: "negativeIndexLengthMethods";
-    readonly presets: readonly ["stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferNegativeIndex", undefined>;
-export default _default;

package/lib/rules/negativeIndexLengthMethods.js

@@ -1,178 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
-import { isTypeRecursive } from "./utils/isTypeRecursive.js";
-import { getTSNodeRange, hasSameTokens, typescriptLanguage, unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/negativeIndexLengthMethods.ts
-const typedArrayNames = /* @__PURE__ */ new Set([
-	"BigInt64Array",
-	"BigUint64Array",
-	"Float32Array",
-	"Float64Array",
-	"Int8Array",
-	"Int16Array",
-	"Int32Array",
-	"Uint8Array",
-	"Uint8ClampedArray",
-	"Uint16Array",
-	"Uint32Array"
-]);
-const methodConfigurations = /* @__PURE__ */ new Map([
-	["at", {
-		argumentIndexes: [0],
-		supportedTypes: /* @__PURE__ */ new Set([
-			"Array",
-			"String",
-			...typedArrayNames
-		])
-	}],
-	["slice", {
-		argumentIndexes: [0, 1],
-		supportedTypes: /* @__PURE__ */ new Set([
-			"Array",
-			"String",
-			...typedArrayNames
-		])
-	}],
-	["splice", {
-		argumentIndexes: [0],
-		supportedTypes: /* @__PURE__ */ new Set(["Array"])
-	}],
-	["subarray", {
-		argumentIndexes: [0, 1],
-		supportedTypes: new Set(typedArrayNames)
-	}],
-	["toSpliced", {
-		argumentIndexes: [0],
-		supportedTypes: /* @__PURE__ */ new Set(["Array"])
-	}],
-	["with", {
-		argumentIndexes: [0],
-		supportedTypes: /* @__PURE__ */ new Set(["Array", ...typedArrayNames])
-	}]
-]);
-function getNegativeIndexLengthNode(node, target, sourceFile) {
-	const unwrapped = unwrapParenthesizedNode(node);
-	if (!ts$1.isBinaryExpression(unwrapped) || unwrapped.operatorToken.kind !== ts$1.SyntaxKind.MinusToken) return;
-	const right = unwrapParenthesizedNode(unwrapped.right);
-	if (!isPositiveNumericLiteral(right)) return;
-	const left = unwrapParenthesizedNode(unwrapped.left);
-	if (isLengthPropertyAccess(left, target, sourceFile)) return {
-		binaryExpression: unwrapped,
-		lengthNode: left,
-		rightOperand: right
-	};
-	return getNegativeIndexLengthNode(unwrapped.left, target, sourceFile);
-}
-function isLengthPropertyAccess(node, target, sourceFile) {
-	return ts$1.isPropertyAccessExpression(node) && node.name.text === "length" && hasSameTokens(node.expression, target, sourceFile);
-}
-function isPositiveNumericLiteral(node) {
-	if (!ts$1.isNumericLiteral(node)) return false;
-	const value = Number(node.text);
-	return Number.isInteger(value) && value > 0;
-}
-function isSupportedType(node, typeChecker, supportedTypes) {
-	return isTypeRecursive(getConstrainedTypeAtLocation(node, typeChecker), (constituent) => {
-		if ((constituent.flags & ts$1.TypeFlags.Any) !== 0) return true;
-		if (typeChecker.isArrayType(constituent) || typeChecker.isTupleType(constituent)) return supportedTypes.has("Array");
-		const typeName = constituent.getSymbol()?.getName();
-		if (typeName) return supportedTypes.has(typeName);
-		if (constituent.isStringLiteral() || (constituent.flags & ts$1.TypeFlags.String) !== 0) return supportedTypes.has("String");
-		return false;
-	});
-}
-function isValidPrototypePattern(node, method) {
-	if (ts$1.isArrayLiteralExpression(node) && !node.elements.length) return true;
-	if (method === "slice" && ts$1.isStringLiteral(node) && node.text === "") return true;
-	if (!ts$1.isPropertyAccessExpression(node) || node.name.text !== "prototype") return false;
-	const object = node.expression;
-	if (!ts$1.isIdentifier(object)) return false;
-	return !!methodConfigurations.get(method)?.supportedTypes.has(object.text);
-}
-function parseCallExpression(node) {
-	if (!ts$1.isPropertyAccessExpression(node.expression)) return;
-	const methodName = node.expression.name.text;
-	const receiver = node.expression.expression;
-	if (methodConfigurations.has(methodName)) return {
-		argumentNodes: node.arguments,
-		method: methodName,
-		target: receiver
-	};
-	if (methodName !== "call" && methodName !== "apply") return;
-	return parsePrototypeCall(node, methodName === "apply");
-}
-function parsePrototypeCall(node, isApply) {
-	if (!ts$1.isPropertyAccessExpression(node.expression)) return;
-	const callee = node.expression.expression;
-	if (!ts$1.isPropertyAccessExpression(callee)) return;
-	const method = callee.name.text;
-	if (!methodConfigurations.has(method)) return;
-	const prototypeObject = callee.expression;
-	if (!isValidPrototypePattern(prototypeObject, method)) return;
-	const [targetArgument, ...restArguments] = node.arguments;
-	if (!targetArgument) return;
-	if (isApply) {
-		const arrayArgument = restArguments[0];
-		if (!arrayArgument || !ts$1.isArrayLiteralExpression(arrayArgument)) return;
-		return {
-			argumentNodes: arrayArgument.elements.filter((element) => !ts$1.isSpreadElement(element)),
-			method,
-			target: targetArgument
-		};
-	}
-	return {
-		argumentNodes: restArguments,
-		method,
-		target: targetArgument
-	};
-}
-var negativeIndexLengthMethods_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Prefer negative index over `.length - index` for `at`, `slice`, `splice`, and similar methods.",
-		id: "negativeIndexLengthMethods",
-		presets: ["stylisticStrict"]
-	},
-	messages: { preferNegativeIndex: {
-		primary: "Prefer using a negative index over `.length - index` for `{{ method }}`.",
-		secondary: ["Negative indices are more concise and express the intent of accessing from the end more clearly.", "Methods like `.at()`, `.slice()`, and `.splice()` support negative indices natively."],
-		suggestions: ["Use a negative index instead of subtracting from `.length`."]
-	} },
-	setup(context) {
-		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
-			const parsed = parseCallExpression(node);
-			if (!parsed) return;
-			const { argumentNodes, method, target } = parsed;
-			const methodConfiguration = methodConfigurations.get(method);
-			if (!methodConfiguration) return;
-			if (!isSupportedType(target, typeChecker, methodConfiguration.supportedTypes)) return;
-			const fixableArguments = [];
-			for (const index of methodConfiguration.argumentIndexes) {
-				const argument = argumentNodes[index];
-				if (!argument) continue;
-				const info = getNegativeIndexLengthNode(argument, target, sourceFile);
-				if (info) fixableArguments.push({
-					argument,
-					info
-				});
-			}
-			if (!fixableArguments.length) return;
-			context.report({
-				data: { method },
-				fix: fixableArguments.map(({ info }) => {
-					return {
-						range: {
-							begin: info.binaryExpression.getStart(sourceFile),
-							end: info.binaryExpression.getEnd()
-						},
-						text: `-${info.rightOperand.getText(sourceFile)}`
-					};
-				}),
-				message: "preferNegativeIndex",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { negativeIndexLengthMethods_default as default };

package/lib/rules/negativeZeroComparisons.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports comparisons with -0 that may not behave as expected.";
-    readonly id: "negativeZeroComparisons";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unexpectedNegativeZeroComparison", undefined>;
-export default _default;

package/lib/rules/negativeZeroComparisons.js

@@ -1,46 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { isComparisonOperator, isEqualityOperator, isNegatedEqualityOperator } from "./utils/operators.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/negativeZeroComparisons.ts
-function isNegativeZero(node) {
-	return node.kind === SyntaxKind.PrefixUnaryExpression && node.operator === SyntaxKind.MinusToken && node.operand.kind === SyntaxKind.NumericLiteral && node.operand.text === "0";
-}
-var negativeZeroComparisons_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports comparisons with -0 that may not behave as expected.",
-		id: "negativeZeroComparisons",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { unexpectedNegativeZeroComparison: {
-		primary: "Comparisons with -0 using {{ operator }} do not distinguish between -0 and +0.",
-		secondary: ["In JavaScript, -0 and +0 are considered equal when using comparison operators like === or ==, even though they are distinct values.", "To properly check for -0, use `Object.is(value, -0)` which correctly distinguishes between -0 and +0."],
-		suggestions: ["Use `Object.is()` to reliably check if a value is -0."]
-	} },
-	setup(context) {
-		function generateObjectIsText(node, isNegated, sourceFile) {
-			const objectIsCall = `Object.is(${node.left.getText(sourceFile)}, ${node.right.getText(sourceFile)})`;
-			return isNegated ? `!${objectIsCall}` : objectIsCall;
-		}
-		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
-			if (!isComparisonOperator(node.operatorToken) || !isNegativeZero(node.left) && !isNegativeZero(node.right)) return;
-			const operator = node.operatorToken.getText(sourceFile);
-			const range = {
-				begin: node.getStart(sourceFile),
-				end: node.getEnd()
-			};
-			context.report({
-				data: { operator },
-				message: "unexpectedNegativeZeroComparison",
-				range,
-				suggestions: isEqualityOperator(node.operatorToken) ? [{
-					id: "useObjectIs",
-					range,
-					text: generateObjectIsText(node, isNegatedEqualityOperator(node.operatorToken), sourceFile)
-				}] : void 0
-			});
-		} } };
-	}
-});
-//#endregion
-export { negativeZeroComparisons_default as default };

package/lib/rules/nestedStandaloneIfs.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports `if` statements that are the only statement inside an `else` block or inside another `if` without an `else`.";
-    readonly id: "nestedStandaloneIfs";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "lonelyIfInElse" | "lonelyIfInIf", undefined>;
-export default _default;