@flint.fyi/ts 0.20.0 → 0.22.0

package/lib/rules/globalAssignments.js

@@ -1,47 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, isGlobalVariable, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-import * as tsutils from "ts-api-utils";
-//#region src/rules/globalAssignments.ts
-var globalAssignments_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports attempting to assign to read-only global variables such as undefined, NaN, Infinity, Object, etc.",
-		id: "globalAssignments",
-		presets: ["javascript"]
-	},
-	messages: { noGlobalAssign: {
-		primary: "Read-only global variables should not be reassigned or modified.",
-		secondary: [
-			"Global variables like undefined, NaN, Infinity, and built-in objects like Object and Array are read-only and should not be modified.",
-			"Attempting to reassign these globals can lead to confusing behavior and potential bugs in your code.",
-			"In strict mode, reassigning these globals will throw a TypeError at runtime."
-		],
-		suggestions: ["Use a different variable name instead of shadowing or reassigning globals.", "If you need a similar name, consider using a more specific name that doesn't conflict with global variables."]
-	} },
-	setup(context) {
-		return { visitors: {
-			BinaryExpression: (node, { sourceFile, typeChecker }) => {
-				if (tsutils.isAssignmentKind(node.operatorToken.kind) && isGlobalVariable(node.left, typeChecker)) context.report({
-					message: "noGlobalAssign",
-					range: getTSNodeRange(node.left, sourceFile)
-				});
-			},
-			PostfixUnaryExpression: (node, { sourceFile, typeChecker }) => {
-				if (isGlobalVariable(node.operand, typeChecker)) context.report({
-					message: "noGlobalAssign",
-					range: getTSNodeRange(node.operand, sourceFile)
-				});
-			},
-			PrefixUnaryExpression: (node, { sourceFile, typeChecker }) => {
-				if ((node.operator === SyntaxKind.PlusPlusToken || node.operator === SyntaxKind.MinusMinusToken) && isGlobalVariable(node.operand, typeChecker)) context.report({
-					message: "noGlobalAssign",
-					range: getTSNodeRange(node.operand, sourceFile)
-				});
-			}
-		} };
-	}
-});
-//#endregion
-export { globalAssignments_default as default };
-
-//# sourceMappingURL=globalAssignments.js.map

package/lib/rules/globalObjectCalls.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports calling global objects like Math, JSON, or Reflect as functions.";
-    readonly id: "globalObjectCalls";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noGlobalObjectCall", undefined>;
-export default _default;
-//# sourceMappingURL=globalObjectCalls.d.ts.map

package/lib/rules/globalObjectCalls.js

@@ -1,42 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/globalObjectCalls.ts
-const globalObjects = new Set([
-	"Atomics",
-	"JSON",
-	"Math",
-	"Reflect"
-]);
-var globalObjectCalls_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports calling global objects like Math, JSON, or Reflect as functions.",
-		id: "globalObjectCalls",
-		presets: ["javascript"]
-	},
-	messages: { noGlobalObjectCall: {
-		primary: "{{ name }} is not a function and cannot be called directly.",
-		secondary: ["{{ name }} is a built-in global object that provides utility methods and properties.", "It is not a constructor or function and cannot be called or instantiated."],
-		suggestions: ["Use the static methods available on {{ name }} instead (e.g., {{ name }}.methodName())."]
-	} },
-	setup(context) {
-		function reportGlobalObjectCall(expression, name, sourceFile) {
-			context.report({
-				data: { name },
-				message: "noGlobalObjectCall",
-				range: getTSNodeRange(expression, sourceFile)
-			});
-		}
-		function checkNode({ expression }, { sourceFile }) {
-			if (expression.kind === SyntaxKind.Identifier && globalObjects.has(expression.text)) reportGlobalObjectCall(expression, expression.text, sourceFile);
-		}
-		return { visitors: {
-			CallExpression: checkNode,
-			NewExpression: checkNode
-		} };
-	}
-});
-//#endregion
-export { globalObjectCalls_default as default };
-
-//# sourceMappingURL=globalObjectCalls.js.map

package/lib/rules/globalThisAliases.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using window, self, or global instead of globalThis.";
-    readonly id: "globalThisAliases";
-    readonly presets: readonly ["stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferGlobalThis", undefined>;
-export default _default;
-//# sourceMappingURL=globalThisAliases.d.ts.map

package/lib/rules/globalThisAliases.js

@@ -1,47 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { declarationIncludesGlobal, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/globalThisAliases.ts
-const globalAliases = new Set([
-	"global",
-	"self",
-	"window"
-]);
-function isOnlyGlobalDeclaration(node, typeChecker) {
-	const symbol = typeChecker.getSymbolAtLocation(node);
-	if (!symbol) return false;
-	const declarations = symbol.getDeclarations();
-	if (!declarations?.length) return false;
-	return declarations.every(declarationIncludesGlobal);
-}
-function isPropertyAccess(node) {
-	return ts.isPropertyAccessExpression(node.parent) && node.parent.name === node;
-}
-function isPropertyShorthand(node) {
-	return ts.isShorthandPropertyAssignment(node.parent) && node.parent.name === node;
-}
-var globalThisAliases_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using window, self, or global instead of globalThis.",
-		id: "globalThisAliases",
-		presets: ["stylisticStrict"]
-	},
-	messages: { preferGlobalThis: {
-		primary: "Prefer the standard `globalThis` over the platform-specific `{{ name }}` for accessing the global object.",
-		secondary: ["`globalThis` is the standard way to access the global object across all JavaScript environments.", "Using `window`, `self`, or `global` ties your code to specific environments (browser, web worker, or Node.js)."],
-		suggestions: ["Replace `{{ name }}` with `globalThis`."]
-	} },
-	setup(context) {
-		return { visitors: { Identifier: (node, { sourceFile, typeChecker }) => {
-			if (globalAliases.has(node.text) && !isPropertyAccess(node) && !isPropertyShorthand(node) && isOnlyGlobalDeclaration(node, typeChecker)) context.report({
-				data: { name: node.text },
-				message: "preferGlobalThis",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { globalThisAliases_default as default };
-
-//# sourceMappingURL=globalThisAliases.js.map

package/lib/rules/impliedEvals.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using string arguments in setTimeout, setInterval, setImmediate, execScript, or the Function constructor.";
-    readonly id: "impliedEvals";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "functionConstructor" | "impliedEval", undefined>;
-export default _default;
-//# sourceMappingURL=impliedEvals.d.ts.map

package/lib/rules/impliedEvals.js

@@ -1,130 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { isBuiltinSymbolLike } from "./utils/isBuiltinSymbolLike.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-import * as tsutils from "ts-api-utils";
-//#region src/rules/impliedEvals.ts
-const globalCandidates = new Set([
-	"global",
-	"globalThis",
-	"window"
-]);
-const evalLikeFunctions = new Set([
-	"execScript",
-	"setImmediate",
-	"setInterval",
-	"setTimeout"
-]);
-function getCalleeName(node) {
-	switch (node.kind) {
-		case ts$1.SyntaxKind.ElementAccessExpression:
-			if (ts$1.isIdentifier(node.expression) && globalCandidates.has(node.expression.text) && ts$1.isStringLiteral(node.argumentExpression)) return node.argumentExpression.text;
-			break;
-		case ts$1.SyntaxKind.Identifier: return node.text;
-		case ts$1.SyntaxKind.PropertyAccessExpression:
-			if (ts$1.isIdentifier(node.expression) && globalCandidates.has(node.expression.text)) return node.name.text;
-			break;
-	}
-}
-function isBind(node) {
-	switch (node.kind) {
-		case ts$1.SyntaxKind.Identifier: return node.text === "bind";
-		case ts$1.SyntaxKind.PropertyAccessExpression: return isBind(node.name);
-		default: return false;
-	}
-}
-function isDefinitelyString(type) {
-	if (tsutils.isTypeFlagSet(type, ts$1.TypeFlags.Any | ts$1.TypeFlags.Unknown | ts$1.TypeFlags.Never)) return false;
-	if (type.isUnion()) return type.types.every(isDefinitelyString);
-	return tsutils.isTypeFlagSet(type, ts$1.TypeFlags.StringLike);
-}
-function isFunction$1(node, typeChecker, program) {
-	switch (node.kind) {
-		case ts$1.SyntaxKind.ArrowFunction:
-		case ts$1.SyntaxKind.FunctionDeclaration:
-		case ts$1.SyntaxKind.FunctionExpression: return true;
-		case ts$1.SyntaxKind.CallExpression:
-			if (isBind(node.expression)) return true;
-			return !isDefinitelyString(typeChecker.getTypeAtLocation(node)) && isFunctionType(node, typeChecker, program);
-		case ts$1.SyntaxKind.NoSubstitutionTemplateLiteral:
-		case ts$1.SyntaxKind.StringLiteral:
-		case ts$1.SyntaxKind.TemplateExpression: return false;
-		default: return !isDefinitelyString(typeChecker.getTypeAtLocation(node)) && isFunctionType(node, typeChecker, program);
-	}
-}
-function isFunctionType(node, typeChecker, program) {
-	const type = typeChecker.getTypeAtLocation(node);
-	if (tsutils.isTypeFlagSet(type, ts$1.TypeFlags.Any | ts$1.TypeFlags.Unknown) || isBuiltinSymbolLike(program, type, "Function")) return true;
-	const symbol = type.getSymbol();
-	if (symbol && tsutils.isSymbolFlagSet(symbol, ts$1.SymbolFlags.Function | ts$1.SymbolFlags.Method)) return true;
-	return !!typeChecker.getSignaturesOfType(type, ts$1.SignatureKind.Call).length;
-}
-function isReferenceToGlobalFunction(node, typeChecker) {
-	if (ts$1.isPropertyAccessExpression(node.expression) || ts$1.isElementAccessExpression(node.expression)) return true;
-	const symbol = typeChecker.getSymbolAtLocation(node.expression);
-	if (!symbol) return true;
-	return !!symbol.getDeclarations()?.some((declaration) => {
-		const sourceFile = declaration.getSourceFile();
-		return sourceFile.hasNoDefaultLib || sourceFile.fileName.includes("node_modules/@types/node/") || /\/lib\.[^/]*\.d\.ts$/.test(sourceFile.fileName);
-	});
-}
-var impliedEvals_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using string arguments in setTimeout, setInterval, setImmediate, execScript, or the Function constructor.",
-		id: "impliedEvals",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: {
-		functionConstructor: {
-			primary: "Avoid using the unsafe Function constructor to create functions.",
-			secondary: ["The Function constructor evaluates strings as code, similar to eval().", "This makes the code harder to analyze, optimize, and can introduce security vulnerabilities."],
-			suggestions: ["Use a function expression or arrow function instead."]
-		},
-		impliedEval: {
-			primary: "Avoid passing unsafe strings to {{ name }}; pass a function instead.",
-			secondary: ["Passing a string to {{ name }} causes it to be evaluated as code, similar to eval().", "This makes the code harder to analyze, optimize, and can introduce security vulnerabilities."],
-			suggestions: ["Pass a function expression or arrow function as the first argument."]
-		}
-	},
-	setup(context) {
-		function checkCalleeFunction(node, { program, sourceFile, typeChecker }) {
-			if (!node.arguments?.length) return;
-			if (!isBuiltinSymbolLike(program, typeChecker.getTypeAtLocation(node.expression), "FunctionConstructor")) return;
-			context.report({
-				message: "functionConstructor",
-				range: getTSNodeRange(node.expression, sourceFile)
-			});
-		}
-		function checkCalleeEval(node, calleeName, { program, sourceFile, typeChecker }) {
-			const args = node.arguments;
-			if (!args?.length) return;
-			const handler = args[0];
-			if (!evalLikeFunctions.has(calleeName) || isFunction$1(handler, typeChecker, program) || !isReferenceToGlobalFunction(node, typeChecker)) return;
-			context.report({
-				data: { name: calleeName },
-				message: "impliedEval",
-				range: getTSNodeRange(handler, sourceFile)
-			});
-		}
-		function checkNode(node, services) {
-			const calleeName = getCalleeName(node.expression);
-			switch (calleeName) {
-				case "Function":
-					checkCalleeFunction(node, services);
-					break;
-				case void 0: return;
-				default:
-					checkCalleeEval(node, calleeName, services);
-					break;
-			}
-		}
-		return { visitors: {
-			CallExpression: checkNode,
-			NewExpression: checkNode
-		} };
-	}
-});
-//#endregion
-export { impliedEvals_default as default };
-
-//# sourceMappingURL=impliedEvals.js.map

package/lib/rules/importEmptyBlocks.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports empty named import blocks.";
-    readonly id: "importEmptyBlocks";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noEmptyNamedBlocksOnly" | "noEmptyNamedBlocksWithOther", undefined>;
-export default _default;
-//# sourceMappingURL=importEmptyBlocks.d.ts.map

package/lib/rules/importEmptyBlocks.js

@@ -1,53 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/importEmptyBlocks.ts
-var importEmptyBlocks_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports empty named import blocks.",
-		id: "importEmptyBlocks",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: {
-		noEmptyNamedBlocksOnly: {
-			primary: "Empty named import blocks are unnecessary.",
-			secondary: ["An empty `{ }` in an import statement has no effect and can be removed."],
-			suggestions: ["Remove the entire import statement.", "Convert to a side-effect only import."]
-		},
-		noEmptyNamedBlocksWithOther: {
-			primary: "Empty named import blocks are unnecessary.",
-			secondary: ["An empty `{ }` in an import statement has no effect and can be removed."],
-			suggestions: ["Remove the empty block."]
-		}
-	},
-	setup(context) {
-		return { visitors: { ImportDeclaration: (node, { sourceFile }) => {
-			if (!node.importClause?.namedBindings || !ts.isNamedImports(node.importClause.namedBindings) || node.importClause.namedBindings.elements.length) return;
-			if (!node.importClause.name) context.report({
-				fix: {
-					range: getTSNodeRange(node, sourceFile),
-					text: `import ${node.moduleSpecifier.getText(sourceFile)};`
-				},
-				message: "noEmptyNamedBlocksOnly",
-				range: getTSNodeRange(node.importClause.namedBindings, sourceFile)
-			});
-			const commaToken = node.importClause.getChildren(sourceFile).find((child) => child.kind === ts.SyntaxKind.CommaToken);
-			if (!commaToken) return;
-			context.report({
-				fix: {
-					range: {
-						begin: commaToken.getStart(sourceFile),
-						end: node.importClause.namedBindings.getEnd()
-					},
-					text: ""
-				},
-				message: "noEmptyNamedBlocksWithOther",
-				range: getTSNodeRange(node.importClause.namedBindings, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { importEmptyBlocks_default as default };
-
-//# sourceMappingURL=importEmptyBlocks.js.map

package/lib/rules/importTypeSideEffects.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports imports that use inline type qualifiers on all specifiers when a top-level type qualifier should be used instead.";
-    readonly id: "importTypeSideEffects";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "useTopLevelQualifier", undefined>;
-export default _default;
-//# sourceMappingURL=importTypeSideEffects.d.ts.map

package/lib/rules/importTypeSideEffects.js

@@ -1,31 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts, { SyntaxKind } from "typescript";
-//#region src/rules/importTypeSideEffects.ts
-var importTypeSideEffects_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports imports that use inline type qualifiers on all specifiers when a top-level type qualifier should be used instead.",
-		id: "importTypeSideEffects",
-		presets: ["logical"]
-	},
-	messages: { useTopLevelQualifier: {
-		primary: "Every specifier in this import is a type, so a single top-level `import type` would be cleaner.",
-		secondary: ["When all specifiers in an import have inline `type` qualifiers, TypeScript's `verbatimModuleSyntax` leaves behind an empty import statement.", "This creates an unnecessary side-effect import at runtime."],
-		suggestions: ["Replace `import { type A, type B }` with `import type { A, B }`."]
-	} },
-	setup(context) {
-		return { visitors: { ImportDeclaration: (node, { sourceFile }) => {
-			if (!node.importClause || node.importClause.name || node.importClause.phaseModifier === SyntaxKind.TypeKeyword) return;
-			const namedBindings = node.importClause.namedBindings;
-			if (!namedBindings || !ts.isNamedImports(namedBindings) || !namedBindings.elements.length || namedBindings.elements.some((element) => !element.isTypeOnly)) return;
-			context.report({
-				message: "useTopLevelQualifier",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { importTypeSideEffects_default as default };
-
-//# sourceMappingURL=importTypeSideEffects.js.map

package/lib/rules/indexedObjectTypes.d.ts

@@ -1,16 +0,0 @@
-import { z } from "zod/v4";
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports indexed object types that don't match the configured style.";
-    readonly id: "indexedObjectTypes";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferIndexSignature" | "preferRecord", {
-    style: z.ZodDefault<z.ZodEnum<{
-        record: "record";
-        "index-signature": "index-signature";
-    }>>;
-}>;
-export default _default;
-//# sourceMappingURL=indexedObjectTypes.d.ts.map

package/lib/rules/indexedObjectTypes.js

@@ -1,83 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, isGlobalDeclaration, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-import { z } from "zod/v4";
-//#region src/rules/indexedObjectTypes.ts
-function getSingleIndexSignature(members) {
-	if (members.length !== 1) return;
-	const member = members[0];
-	if (member.kind !== ts$1.SyntaxKind.IndexSignature) return;
-	return member;
-}
-function getTypeName(node) {
-	if (node.kind === ts$1.SyntaxKind.InterfaceDeclaration) return node.name.text;
-	let current = node.parent;
-	while (current) {
-		if (ts$1.isTypeAliasDeclaration(current)) return current.name.text;
-		current = current.parent;
-	}
-}
-function isDirectlyRecursive(node, parentTypeName) {
-	switch (node.kind) {
-		case ts$1.SyntaxKind.ConditionalType: return isDirectlyRecursive(node.checkType, parentTypeName) || isDirectlyRecursive(node.extendsType, parentTypeName) || isDirectlyRecursive(node.trueType, parentTypeName) || isDirectlyRecursive(node.falseType, parentTypeName);
-		case ts$1.SyntaxKind.IndexedAccessType: return isDirectlyRecursive(node.objectType, parentTypeName) || isDirectlyRecursive(node.indexType, parentTypeName);
-		case ts$1.SyntaxKind.IntersectionType:
-		case ts$1.SyntaxKind.UnionType: return node.types.some((type) => isDirectlyRecursive(type, parentTypeName));
-		case ts$1.SyntaxKind.ParenthesizedType: return isDirectlyRecursive(node.type, parentTypeName);
-		case ts$1.SyntaxKind.TypeReference:
-			if (node.typeName.kind === ts$1.SyntaxKind.Identifier && node.typeName.text === parentTypeName) return true;
-			if (node.typeArguments) return node.typeArguments.some((arg) => isDirectlyRecursive(arg, parentTypeName));
-			return false;
-		default: return false;
-	}
-}
-var indexedObjectTypes_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports indexed object types that don't match the configured style.",
-		id: "indexedObjectTypes",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: {
-		preferIndexSignature: {
-			primary: "Prefer an index signature over `Record<K, V>`.",
-			secondary: ["TypeScript provides two equivalent ways to define indexed object types: `Record<K, V>` and `{ [key: K]: V }`.", "Using index signatures consistently matches the more traditional TypeScript syntax."],
-			suggestions: ["Replace `Record<K, V>` with `{ [key: K]: V }`."]
-		},
-		preferRecord: {
-			primary: "Prefer `Record<K, V>` over an index signature.",
-			secondary: ["TypeScript provides two equivalent ways to define indexed object types: `Record<K, V>` and `{ [key: K]: V }`.", "Using `Record<K, V>` consistently is more concise and idiomatic."],
-			suggestions: ["Replace the index signature with `Record<K, V>`."]
-		}
-	},
-	options: { style: z.enum(["index-signature", "record"]).default("record").describe("Which indexed object type syntax to enforce: 'record' for `Record<K, V>`, or 'index-signature' for `{ [key: K]: V }`.") },
-	setup(context) {
-		function checkForRecord(node, members, sourceFile) {
-			const member = getSingleIndexSignature(members);
-			if (!member?.type) return;
-			const typeName = getTypeName(node);
-			if (typeName && isDirectlyRecursive(member.type, typeName)) return;
-			context.report({
-				message: "preferRecord",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		}
-		return { visitors: {
-			InterfaceDeclaration: (node, { options, sourceFile }) => {
-				if (options.style === "record" && !node.heritageClauses?.length) checkForRecord(node, node.members, sourceFile);
-			},
-			TypeLiteral: (node, { options, sourceFile }) => {
-				if (options.style === "record") checkForRecord(node, node.members, sourceFile);
-			},
-			TypeReference: (node, { options, sourceFile, typeChecker }) => {
-				if (options.style === "index-signature" && node.typeName.kind === ts$1.SyntaxKind.Identifier && node.typeName.text === "Record" && isGlobalDeclaration(node.typeName, typeChecker) && node.typeArguments?.length === 2) context.report({
-					message: "preferIndexSignature",
-					range: getTSNodeRange(node, sourceFile)
-				});
-			}
-		} };
-	}
-});
-//#endregion
-export { indexedObjectTypes_default as default };
-
-//# sourceMappingURL=indexedObjectTypes.js.map

package/lib/rules/instanceOfArrays.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using `instanceof Array` instead of `Array.isArray()`.";
-    readonly id: "instanceOfArrays";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "useArrayIsArray", undefined>;
-export default _default;
-//# sourceMappingURL=instanceOfArrays.d.ts.map

package/lib/rules/instanceOfArrays.js

@@ -1,31 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage, unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/instanceOfArrays.ts
-var instanceOfArrays_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using `instanceof Array` instead of `Array.isArray()`.",
-		id: "instanceOfArrays",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { useArrayIsArray: {
-		primary: "Use `Array.isArray()` instead of `instanceof Array`.",
-		secondary: ["The `instanceof Array` check can fail across different execution contexts (e.g., iframes or realms).", "It may also give incorrect results for array-like objects."],
-		suggestions: ["Use `Array.isArray(value)` for reliable array detection."]
-	} },
-	setup(context) {
-		return { visitors: { BinaryExpression: (node, { sourceFile, typeChecker }) => {
-			if (node.operatorToken.kind !== SyntaxKind.InstanceOfKeyword) return;
-			const right = unwrapParenthesizedNode(node.right);
-			if (right.kind !== SyntaxKind.Identifier || right.text !== "Array" || !isGlobalDeclarationOfName(right, "Array", typeChecker)) return;
-			context.report({
-				message: "useArrayIsArray",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { instanceOfArrays_default as default };
-
-//# sourceMappingURL=instanceOfArrays.js.map

package/lib/rules/irregularWhitespaces.d.ts

@@ -1,16 +0,0 @@
-import { z } from "zod/v4";
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports irregular whitespace characters that can cause issues with code parsing and display.";
-    readonly id: "irregularWhitespaces";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "irregularWhitespace", {
-    skipComments: z.ZodDefault<z.ZodBoolean>;
-    skipJSXText: z.ZodDefault<z.ZodBoolean>;
-    skipRegularExpressions: z.ZodDefault<z.ZodBoolean>;
-    skipTemplates: z.ZodDefault<z.ZodBoolean>;
-}>;
-export default _default;
-//# sourceMappingURL=irregularWhitespaces.d.ts.map