@flint.fyi/ts 0.14.6 → 0.18.0

package/lib/rules/globalObjectCalls.js

@@ -1,43 +1,42 @@
-import * as ts from "typescript";
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
-const globalObjects = new Set(["Atomics", "JSON", "Math", "Reflect"]);
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports calling global objects like Math, JSON, or Reflect as functions.",
-        id: "globalObjectCalls",
-        preset: "untyped",
-    },
-    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) {
-            context.report({
-                data: { name },
-                message: "noGlobalObjectCall",
-                range: getTSNodeRange(expression, context.sourceFile),
-            });
-        }
-        function checkNode({ expression }) {
-            if (ts.isIdentifier(expression) && globalObjects.has(expression.text)) {
-                reportGlobalObjectCall(expression, expression.text);
-            }
-        }
-        return {
-            visitors: {
-                CallExpression: checkNode,
-                NewExpression: checkNode,
-            },
-        };
-    },
+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

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

package/lib/rules/globalThisAliases.js

@@ -0,0 +1,47 @@
+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

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

package/lib/rules/impliedEvals.js

@@ -0,0 +1,130 @@
+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

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

package/lib/rules/importEmptyBlocks.js

@@ -0,0 +1,53 @@
+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

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

package/lib/rules/importTypeSideEffects.js

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,16 @@
+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: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferIndexSignature" | "preferRecord", {
+    readonly style: z.ZodDefault<z.ZodEnum<{
+        record: "record";
+        "index-signature": "index-signature";
+    }>>;
+}>;
+export default _default;
+//# sourceMappingURL=indexedObjectTypes.d.ts.map

package/lib/rules/indexedObjectTypes.js

@@ -0,0 +1,83 @@
+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

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

package/lib/rules/instanceOfArrays.js

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,16 @@
+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: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "irregularWhitespace", {
+    readonly skipComments: z.ZodDefault<z.ZodBoolean>;
+    readonly skipJSXText: z.ZodDefault<z.ZodBoolean>;
+    readonly skipRegularExpressions: z.ZodDefault<z.ZodBoolean>;
+    readonly skipTemplates: z.ZodDefault<z.ZodBoolean>;
+}>;
+export default _default;
+//# sourceMappingURL=irregularWhitespaces.d.ts.map

package/lib/rules/irregularWhitespaces.js

@@ -0,0 +1,97 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+import { z } from "zod/v4";
+//#region src/rules/irregularWhitespaces.ts
+function findIrregularWhitespaces(text) {
+	const irregularWhitespacePattern = /[\f\v\x85\ufeff\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u202f\u205f\u3000\u2028\u2029]/gu;
+	const matches = [];
+	let match;
+	while ((match = irregularWhitespacePattern.exec(text)) !== null) matches.push({
+		index: match.index,
+		length: match[0].length
+	});
+	return matches;
+}
+function isInRange(position, start, end) {
+	return position >= start && position < end;
+}
+var irregularWhitespaces_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports irregular whitespace characters that can cause issues with code parsing and display.",
+		id: "irregularWhitespaces",
+		presets: ["logical"]
+	},
+	messages: { irregularWhitespace: {
+		primary: "Irregular whitespace characters can cause unexpected behavior and display issues.",
+		secondary: [
+			"Irregular whitespace includes characters like non-breaking spaces (\\u00A0), zero-width spaces (\\u200B), and various Unicode space characters.",
+			"These characters are often invisible or look like regular spaces, but may be interpreted differently by tools and parsers.",
+			"They can be accidentally introduced through copy-paste from external sources."
+		],
+		suggestions: ["Replace irregular whitespace with regular spaces or tabs.", "Remove the whitespace if it is unnecessary."]
+	} },
+	options: {
+		skipComments: z.boolean().default(false).describe("Whether to allow irregular whitespace in comments."),
+		skipJSXText: z.boolean().default(false).describe("Whether to allow irregular whitespace in JSX text content."),
+		skipRegularExpressions: z.boolean().default(false).describe("Whether to allow irregular whitespace in regular expression literals."),
+		skipTemplates: z.boolean().default(false).describe("Whether to allow irregular whitespace in template literals.")
+	},
+	setup(context) {
+		return { visitors: { SourceFile: (node, { options, sourceFile }) => {
+			const text = sourceFile.getFullText();
+			const allMatches = findIrregularWhitespaces(text);
+			if (!allMatches.length) return;
+			const excludedRanges = [];
+			function collectExcludedRanges(astNode) {
+				if (astNode.kind === ts$1.SyntaxKind.StringLiteral) excludedRanges.push({
+					end: astNode.getEnd(),
+					start: astNode.getStart(sourceFile)
+				});
+				if (options.skipRegularExpressions && astNode.kind === ts$1.SyntaxKind.RegularExpressionLiteral) excludedRanges.push({
+					end: astNode.getEnd(),
+					start: astNode.getStart(sourceFile)
+				});
+				if (options.skipTemplates && (astNode.kind === ts$1.SyntaxKind.NoSubstitutionTemplateLiteral || astNode.kind === ts$1.SyntaxKind.TemplateHead || astNode.kind === ts$1.SyntaxKind.TemplateMiddle || astNode.kind === ts$1.SyntaxKind.TemplateTail)) excludedRanges.push({
+					end: astNode.getEnd(),
+					start: astNode.getStart(sourceFile)
+				});
+				if (options.skipJSXText && astNode.kind === ts$1.SyntaxKind.JsxText) excludedRanges.push({
+					end: astNode.getEnd(),
+					start: astNode.getFullStart()
+				});
+				ts$1.forEachChild(astNode, collectExcludedRanges);
+			}
+			collectExcludedRanges(node);
+			if (options.skipComments) {
+				const commentRanges = [...ts$1.getLeadingCommentRanges(text, 0) ?? []];
+				function collectCommentRanges(astNode) {
+					const leading = ts$1.getLeadingCommentRanges(text, astNode.getFullStart());
+					if (leading) commentRanges.push(...leading);
+					const trailing = ts$1.getTrailingCommentRanges(text, astNode.getEnd());
+					if (trailing) commentRanges.push(...trailing);
+					ts$1.forEachChild(astNode, collectCommentRanges);
+				}
+				collectCommentRanges(node);
+				for (const range of commentRanges) excludedRanges.push({
+					end: range.end,
+					start: range.pos
+				});
+			}
+			for (const match of allMatches) {
+				if (excludedRanges.some((range) => isInRange(match.index, range.start, range.end))) continue;
+				context.report({
+					message: "irregularWhitespace",
+					range: {
+						begin: match.index,
+						end: match.index + match.length
+					}
+				});
+			}
+		} } };
+	}
+});
+//#endregion
+export { irregularWhitespaces_default as default };
+
+//# sourceMappingURL=irregularWhitespaces.js.map