@flint.fyi/ts 0.15.0 → 0.18.1

package/lib/rules/utils/discriminateAnyType.js

@@ -1,42 +1,38 @@
+import ts from "typescript";
 import * as tsutils from "ts-api-utils";
-import * as ts from "typescript";
-export var AnyType;
-(function (AnyType) {
-    AnyType[AnyType["Any"] = 0] = "Any";
-    AnyType[AnyType["PromiseAny"] = 1] = "PromiseAny";
-    AnyType[AnyType["AnyArray"] = 2] = "AnyArray";
-    AnyType[AnyType["Safe"] = 3] = "Safe";
-})(AnyType || (AnyType = {}));
+import { nullThrows } from "@flint.fyi/utils";
+//#region src/rules/utils/discriminateAnyType.ts
+const AnyType = {
+	Any: "any",
+	AnyArray: "any[]",
+	Error: "error",
+	PromiseAny: "Promise<any>",
+	Safe: "safe"
+};
 /**
- * @returns `AnyType.Any` if the type is `any`, `AnyType.AnyArray` if the type is `any[]` or `readonly any[]`, `AnyType.PromiseAny` if the type is `Promise&lt;any>`,
- * otherwise it returns `AnyType.Safe`.
- */
-export function discriminateAnyType(type, checker, program, tsNode) {
-    return discriminateAnyTypeWorker(type, checker, program, tsNode, new Set());
+* @returns `AnyType.Any` if the type is `any`, `AnyType.AnyArray` if the type is `any[]` or `readonly any[]`, `AnyType.PromiseAny` if the type is `Promise&lt;any>`,
+* `AnyType.Error` if the type is an intrinsic error type, otherwise it returns `AnyType.Safe`.
+*/
+function discriminateAnyType(type, checker, tsNode) {
+	return discriminateAnyTypeWorker(type, checker, tsNode, /* @__PURE__ */ new Set());
 }
-function discriminateAnyTypeWorker(type, checker, program, tsNode, visited) {
-    if (visited.has(type)) {
-        return AnyType.Safe;
-    }
-    visited.add(type);
-    if (tsutils.isTypeFlagSet(type, ts.TypeFlags.Any)) {
-        return AnyType.Any;
-    }
-    if (checker.isArrayType(type) &&
-        tsutils.isTypeFlagSet(checker.getTypeArguments(type)[0], ts.TypeFlags.Any)) {
-        return AnyType.AnyArray;
-    }
-    for (const part of tsutils.typeConstituents(type)) {
-        if (tsutils.isThenableType(checker, tsNode, part)) {
-            const awaitedType = checker.getAwaitedType(part);
-            if (awaitedType) {
-                const awaitedAnyType = discriminateAnyTypeWorker(awaitedType, checker, program, tsNode, visited);
-                if (awaitedAnyType === AnyType.Any) {
-                    return AnyType.PromiseAny;
-                }
-            }
-        }
-    }
-    return AnyType.Safe;
+function discriminateAnyTypeWorker(type, checker, tsNode, visited) {
+	if (visited.has(type)) return AnyType.Safe;
+	visited.add(type);
+	if (tsutils.isTypeFlagSet(type, ts.TypeFlags.Any)) return tsutils.isIntrinsicErrorType(type) ? AnyType.Error : AnyType.Any;
+	if (checker.isArrayType(type)) {
+		const elementType = nullThrows(checker.getTypeArguments(type)[0], "Array type should have at least one type argument");
+		if (tsutils.isTypeFlagSet(elementType, ts.TypeFlags.Any) && !tsutils.isIntrinsicErrorType(elementType)) return AnyType.AnyArray;
+	}
+	for (const part of tsutils.typeConstituents(type)) if (tsutils.isThenableType(checker, tsNode, part)) {
+		const awaitedType = checker.getAwaitedType(part);
+		if (awaitedType) {
+			if (discriminateAnyTypeWorker(awaitedType, checker, tsNode, visited) === AnyType.Any && !tsutils.isIntrinsicErrorType(awaitedType)) return AnyType.PromiseAny;
+		}
+	}
+	return AnyType.Safe;
 }
+//#endregion
+export { AnyType, discriminateAnyType };
+
 //# sourceMappingURL=discriminateAnyType.js.map

package/lib/rules/utils/equalityOperators.d.ts

@@ -0,0 +1,9 @@
+import type { AST } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+export type EqualityOperator = "!=" | "!==" | "==" | "===";
+export declare function isNullishLiteral(node: AST.Expression): boolean;
+export declare function isUndefinedIdentifier(node: AST.Expression): boolean;
+export declare function toEqualityOperator(kind: SyntaxKind): EqualityOperator | undefined;
+export declare function toLooseOperator(operator: EqualityOperator): EqualityOperator;
+export declare function toStrictOperator(operator: EqualityOperator): EqualityOperator;
+//# sourceMappingURL=equalityOperators.d.ts.map

package/lib/rules/utils/equalityOperators.js

@@ -0,0 +1,36 @@
+import { unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/utils/equalityOperators.ts
+function isNullishLiteral(node) {
+	return isNullLiteral(node) || isUndefinedIdentifier(node);
+}
+function isUndefinedIdentifier(node) {
+	const unwrapped = unwrapParenthesizedNode(node);
+	return unwrapped.kind === SyntaxKind.Identifier && unwrapped.text === "undefined";
+}
+function toEqualityOperator(kind) {
+	switch (kind) {
+		case SyntaxKind.EqualsEqualsEqualsToken: return "===";
+		case SyntaxKind.EqualsEqualsToken: return "==";
+		case SyntaxKind.ExclamationEqualsEqualsToken: return "!==";
+		case SyntaxKind.ExclamationEqualsToken: return "!=";
+		default: return;
+	}
+}
+function toLooseOperator(operator) {
+	if (operator === "===") return "==";
+	if (operator === "!==") return "!=";
+	return operator;
+}
+function toStrictOperator(operator) {
+	if (operator === "==") return "===";
+	if (operator === "!=") return "!==";
+	return operator;
+}
+function isNullLiteral(node) {
+	return unwrapParenthesizedNode(node).kind === SyntaxKind.NullKeyword;
+}
+//#endregion
+export { isNullishLiteral, isUndefinedIdentifier, toEqualityOperator, toLooseOperator, toStrictOperator };
+
+//# sourceMappingURL=equalityOperators.js.map

package/lib/rules/utils/forEachReturnStatement.d.ts

@@ -0,0 +1,3 @@
+import * as ts from "typescript";
+export declare function forEachReturnStatement<T>(body: ts.Block, visitor: (statement: ts.ReturnStatement) => T): T | undefined;
+//# sourceMappingURL=forEachReturnStatement.d.ts.map

package/lib/rules/utils/forEachReturnStatement.js

@@ -0,0 +1,29 @@
+import * as ts$1 from "typescript";
+//#region src/rules/utils/forEachReturnStatement.ts
+function forEachReturnStatement(body, visitor) {
+	return traverse(body);
+	function traverse(node) {
+		switch (node.kind) {
+			case ts$1.SyntaxKind.Block:
+			case ts$1.SyntaxKind.CaseBlock:
+			case ts$1.SyntaxKind.CaseClause:
+			case ts$1.SyntaxKind.CatchClause:
+			case ts$1.SyntaxKind.DefaultClause:
+			case ts$1.SyntaxKind.DoStatement:
+			case ts$1.SyntaxKind.ForInStatement:
+			case ts$1.SyntaxKind.ForOfStatement:
+			case ts$1.SyntaxKind.ForStatement:
+			case ts$1.SyntaxKind.IfStatement:
+			case ts$1.SyntaxKind.LabeledStatement:
+			case ts$1.SyntaxKind.SwitchStatement:
+			case ts$1.SyntaxKind.TryStatement:
+			case ts$1.SyntaxKind.WhileStatement:
+			case ts$1.SyntaxKind.WithStatement: return ts$1.forEachChild(node, traverse);
+			case ts$1.SyntaxKind.ReturnStatement: return visitor(node);
+		}
+	}
+}
+//#endregion
+export { forEachReturnStatement };
+
+//# sourceMappingURL=forEachReturnStatement.js.map

package/lib/rules/utils/formatReportedType.d.ts

@@ -0,0 +1,4 @@
+import type { Checker } from "@flint.fyi/typescript-language";
+import type ts from "typescript";
+export declare function formatReportedType(type: ts.Type, typeChecker: Checker): string;
+//# sourceMappingURL=formatReportedType.d.ts.map

package/lib/rules/utils/formatReportedType.js

@@ -0,0 +1,9 @@
+import * as tsutils from "ts-api-utils";
+//#region src/rules/utils/formatReportedType.ts
+function formatReportedType(type, typeChecker) {
+	return tsutils.isIntrinsicErrorType(type) ? "error" : typeChecker.typeToString(type);
+}
+//#endregion
+export { formatReportedType };
+
+//# sourceMappingURL=formatReportedType.js.map

package/lib/rules/utils/getConstrainedType.d.ts

@@ -1,3 +1,3 @@
-import * as ts from "typescript";
-export declare function getConstrainedTypeAtLocation(node: ts.Node, typeChecker: ts.TypeChecker): ts.Type;
+import type { AST, Checker } from "@flint.fyi/typescript-language";
+export declare function getConstrainedTypeAtLocation(node: AST.Expression, typeChecker: Checker): import("typescript").Type;
 //# sourceMappingURL=getConstrainedType.d.ts.map

package/lib/rules/utils/getConstrainedType.js

@@ -1,5 +1,9 @@
-export function getConstrainedTypeAtLocation(node, typeChecker) {
-    const type = typeChecker.getTypeAtLocation(node);
-    return typeChecker.getBaseConstraintOfType(type) ?? type;
+//#region src/rules/utils/getConstrainedType.ts
+function getConstrainedTypeAtLocation(node, typeChecker) {
+	const type = typeChecker.getTypeAtLocation(node);
+	return typeChecker.getBaseConstraintOfType(type) ?? type;
 }
+//#endregion
+export { getConstrainedTypeAtLocation };
+
 //# sourceMappingURL=getConstrainedType.js.map

package/lib/rules/utils/getFunctionName.d.ts

@@ -0,0 +1,3 @@
+import type { AST } from "@flint.fyi/typescript-language";
+export declare function getFunctionName(node: AST.ArrowFunction | AST.FunctionDeclaration | AST.FunctionExpression | AST.MethodDeclaration | AST.MethodSignature): string | undefined;
+//# sourceMappingURL=getFunctionName.d.ts.map

package/lib/rules/utils/getFunctionName.js

@@ -0,0 +1,16 @@
+import ts from "typescript";
+//#region src/rules/utils/getFunctionName.ts
+function getFunctionName(node) {
+	switch (node.kind) {
+		case ts.SyntaxKind.ArrowFunction: return ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name) ? node.parent.name.text : void 0;
+		case ts.SyntaxKind.FunctionDeclaration:
+		case ts.SyntaxKind.FunctionExpression: return node.name?.text;
+		case ts.SyntaxKind.MethodDeclaration:
+		case ts.SyntaxKind.MethodSignature: return ts.isIdentifier(node.name) ? node.name.text : void 0;
+		default: return;
+	}
+}
+//#endregion
+export { getFunctionName };
+
+//# sourceMappingURL=getFunctionName.js.map

package/lib/rules/utils/getRegExpConstruction.d.ts

@@ -0,0 +1,10 @@
+import { type AST, type TypeScriptFileServices } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+export declare function getRegExpConstruction(node: AST.CallExpression | AST.NewExpression, { sourceFile, typeChecker }: TypeScriptFileServices): {
+    args: ts.NodeArray<AST.Expression>;
+    flags: string;
+    pattern: string;
+    raw: string;
+    start: number;
+} | undefined;
+//# sourceMappingURL=getRegExpConstruction.d.ts.map

package/lib/rules/utils/getRegExpConstruction.js

@@ -0,0 +1,26 @@
+import { isGlobalDeclarationOfName } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+//#region src/rules/utils/getRegExpConstruction.ts
+function getRegExpConstruction(node, { sourceFile, typeChecker }) {
+	if (node.expression.kind !== ts.SyntaxKind.Identifier || node.expression.text !== "RegExp" || !isGlobalDeclarationOfName(node.expression, "RegExp", typeChecker)) return;
+	const args = node.arguments;
+	if (!args?.length) return;
+	const firstArgument = args[0];
+	if (firstArgument.kind !== ts.SyntaxKind.StringLiteral && firstArgument.kind !== ts.SyntaxKind.NoSubstitutionTemplateLiteral) return;
+	let flags = "";
+	if (args.length >= 2) {
+		const flagsArg = args[1];
+		if (flagsArg?.kind === ts.SyntaxKind.StringLiteral || flagsArg?.kind === ts.SyntaxKind.NoSubstitutionTemplateLiteral) flags = flagsArg.getText(sourceFile).slice(1, -1);
+	}
+	return {
+		args,
+		flags,
+		pattern: firstArgument.getText(sourceFile).slice(1, -1),
+		raw: firstArgument.text,
+		start: firstArgument.getStart(sourceFile)
+	};
+}
+//#endregion
+export { getRegExpConstruction };
+
+//# sourceMappingURL=getRegExpConstruction.js.map

package/lib/rules/utils/getRegExpLiteralDetails.d.ts

@@ -0,0 +1,7 @@
+import type { AST, TypeScriptFileServices } from "@flint.fyi/typescript-language";
+export declare function getRegExpLiteralDetails(node: AST.RegularExpressionLiteral, { sourceFile }: Pick<TypeScriptFileServices, "sourceFile">): {
+    flags: string;
+    pattern: string;
+    start: number;
+};
+//# sourceMappingURL=getRegExpLiteralDetails.d.ts.map

package/lib/rules/utils/getRegExpLiteralDetails.js

@@ -0,0 +1,13 @@
+//#region src/rules/utils/getRegExpLiteralDetails.ts
+function getRegExpLiteralDetails(node, { sourceFile }) {
+	const lastSlash = node.text.lastIndexOf("/");
+	return {
+		flags: node.text.slice(lastSlash + 1),
+		pattern: node.text.slice(1, lastSlash),
+		start: node.getStart(sourceFile) + 1
+	};
+}
+//#endregion
+export { getRegExpLiteralDetails };
+
+//# sourceMappingURL=getRegExpLiteralDetails.js.map

package/lib/rules/utils/getThisExpression.d.ts

@@ -1,3 +1,3 @@
-import * as ts from "typescript";
-export declare function getThisExpression(node: ts.Node): null | ts.ThisExpression;
+import type { AST } from "@flint.fyi/typescript-language";
+export declare function getThisExpression(node: AST.Expression): AST.ThisExpression | null;
 //# sourceMappingURL=getThisExpression.d.ts.map

package/lib/rules/utils/getThisExpression.js

@@ -1,24 +1,16 @@
-import * as tsutils from "ts-api-utils";
-import * as ts from "typescript";
-export function getThisExpression(node) {
-    while (true) {
-        node = skipParentheses(node);
-        if (ts.isCallExpression(node) || tsutils.isAccessExpression(node)) {
-            node = node.expression;
-        }
-        else if (tsutils.isThisExpression(node)) {
-            return node;
-        }
-        else {
-            break;
-        }
-    }
-    return null;
-}
-function skipParentheses(node) {
-    while (ts.isParenthesizedExpression(node)) {
-        node = node.expression;
-    }
-    return node;
+import { skipParentheses } from "./skipParentheses.js";
+import { SyntaxKind } from "typescript";
+//#region src/rules/utils/getThisExpression.ts
+function getThisExpression(node) {
+	while (true) {
+		node = skipParentheses(node);
+		if (node.kind === SyntaxKind.CallExpression || node.kind === SyntaxKind.PropertyAccessExpression || node.kind === SyntaxKind.ElementAccessExpression) node = node.expression;
+		else if (node.kind === SyntaxKind.ThisKeyword) return node;
+		else break;
+	}
+	return null;
 }
+//#endregion
+export { getThisExpression };
+
 //# sourceMappingURL=getThisExpression.js.map

package/lib/rules/utils/isArrayOrTupleTypeAtLocation.d.ts

@@ -0,0 +1,3 @@
+import type { AST, Checker } from "@flint.fyi/typescript-language";
+export declare function isArrayOrTupleTypeAtLocation(node: AST.Expression, typeChecker: Checker): boolean;
+//# sourceMappingURL=isArrayOrTupleTypeAtLocation.d.ts.map

package/lib/rules/utils/isArrayOrTupleTypeAtLocation.js

@@ -0,0 +1,13 @@
+import { getConstrainedTypeAtLocation } from "./getConstrainedType.js";
+import { isTypeRecursive } from "./isTypeRecursive.js";
+//#region src/rules/utils/isArrayOrTupleTypeAtLocation.ts
+function isArrayOrTupleTypeAtLocation(node, typeChecker) {
+	return isArrayOrTupleType(getConstrainedTypeAtLocation(node, typeChecker), typeChecker);
+}
+function isArrayOrTupleType(type, typeChecker) {
+	return isTypeRecursive(type, (constituent) => typeChecker.isArrayType(constituent) || typeChecker.isTupleType(constituent));
+}
+//#endregion
+export { isArrayOrTupleTypeAtLocation };
+
+//# sourceMappingURL=isArrayOrTupleTypeAtLocation.js.map

package/lib/rules/utils/isBuiltinSymbolLike.d.ts

@@ -0,0 +1,3 @@
+import * as ts from "typescript";
+export declare function isBuiltinSymbolLike(program: ts.Program, type: ts.Type, symbolName: string): boolean;
+//# sourceMappingURL=isBuiltinSymbolLike.d.ts.map

package/lib/rules/utils/isBuiltinSymbolLike.js

@@ -0,0 +1,33 @@
+import * as ts$1 from "typescript";
+import * as tsutils from "ts-api-utils";
+//#region src/rules/utils/isBuiltinSymbolLike.ts
+function isBuiltinSymbolLike(program, type, symbolName) {
+	return isBuiltinSymbolLikeRecurser(program, type, (subType) => {
+		const symbol = subType.getSymbol();
+		if (!symbol) return false;
+		const actualSymbolName = symbol.getName();
+		if (actualSymbolName === symbolName && isSymbolFromDefaultLibrary(program, symbol)) return true;
+		if (actualSymbolName === "Function" && tsutils.isObjectType(subType) && tsutils.isObjectFlagSet(subType, ts$1.ObjectFlags.Anonymous)) return false;
+		return null;
+	});
+}
+function isBuiltinSymbolLikeRecurser(program, type, predicate) {
+	if (type.isUnionOrIntersection()) return type.types.some((subType) => isBuiltinSymbolLikeRecurser(program, subType, predicate));
+	const result = predicate(type);
+	if (result !== null) return result;
+	const bases = type.getBaseTypes();
+	if (bases?.length) return bases.some((baseType) => isBuiltinSymbolLikeRecurser(program, baseType, predicate));
+	return false;
+}
+function isSymbolFromDefaultLibrary(program, symbol) {
+	const declarations = symbol.getDeclarations();
+	if (!declarations?.length) return false;
+	return declarations.some((declaration) => {
+		const sourceFile = declaration.getSourceFile();
+		return sourceFile.hasNoDefaultLib || program.isSourceFileDefaultLibrary(sourceFile);
+	});
+}
+//#endregion
+export { isBuiltinSymbolLike };
+
+//# sourceMappingURL=isBuiltinSymbolLike.js.map

package/lib/rules/utils/isDirectEqualityCheck.d.ts

@@ -0,0 +1,4 @@
+import type { AST } from "@flint.fyi/typescript-language";
+import * as ts from "typescript";
+export declare function isDirectEqualityCheck(node: AST.ArrowFunction | AST.FunctionExpression, operators: ts.SyntaxKind[], parameterName: string): AST.Expression | undefined;
+//# sourceMappingURL=isDirectEqualityCheck.d.ts.map

package/lib/rules/utils/isDirectEqualityCheck.js

@@ -0,0 +1,29 @@
+import * as ts$1 from "typescript";
+//#region src/rules/utils/isDirectEqualityCheck.ts
+function isDirectEqualityCheck(node, operators, parameterName) {
+	let body;
+	switch (node.kind) {
+		case ts$1.SyntaxKind.ArrowFunction:
+			body = node.body.kind === ts$1.SyntaxKind.Block ? getDirectReturnExpression(node.body) : node.body;
+			break;
+		case ts$1.SyntaxKind.FunctionExpression:
+			body = getDirectReturnExpression(node.body);
+			break;
+	}
+	if (!body || !ts$1.isBinaryExpression(body)) return;
+	const { left, operatorToken, right } = body;
+	if (!operators.includes(operatorToken.kind)) return;
+	const isLeftParam = ts$1.isIdentifier(left) && left.text === parameterName;
+	const isRightParam = ts$1.isIdentifier(right) && right.text === parameterName;
+	if (isLeftParam && !isRightParam) return right;
+	if (isRightParam && !isLeftParam) return left;
+}
+function getDirectReturnExpression(body) {
+	if (body.statements.length !== 1) return;
+	const statement = body.statements[0];
+	return statement.kind === ts$1.SyntaxKind.ReturnStatement ? statement.expression : void 0;
+}
+//#endregion
+export { isDirectEqualityCheck };
+
+//# sourceMappingURL=isDirectEqualityCheck.js.map

package/lib/rules/utils/isErrorSubclass.d.ts

@@ -0,0 +1,3 @@
+import { type AST, type Checker } from "@flint.fyi/typescript-language";
+export declare function isErrorSubclass(node: AST.ClassDeclaration, typeChecker: Checker): boolean;
+//# sourceMappingURL=isErrorSubclass.d.ts.map

package/lib/rules/utils/isErrorSubclass.js

@@ -0,0 +1,27 @@
+import { isGlobalDeclaration } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+//#region src/rules/utils/isErrorSubclass.ts
+const builtinErrorNames = new Set([
+	"Error",
+	"EvalError",
+	"RangeError",
+	"ReferenceError",
+	"SyntaxError",
+	"TypeError",
+	"URIError"
+]);
+function isErrorSubclass(node, typeChecker) {
+	if (!node.heritageClauses) return false;
+	for (const clause of node.heritageClauses) {
+		if (clause.token !== ts.SyntaxKind.ExtendsKeyword) continue;
+		for (const type of clause.types) {
+			const typeName = type.expression;
+			if (ts.isIdentifier(typeName) && builtinErrorNames.has(typeName.text) && isGlobalDeclaration(typeName, typeChecker)) return true;
+		}
+	}
+	return false;
+}
+//#endregion
+export { isErrorSubclass };
+
+//# sourceMappingURL=isErrorSubclass.js.map

package/lib/rules/utils/isInBooleanContext.d.ts

@@ -0,0 +1,3 @@
+import type { AST } from "@flint.fyi/typescript-language";
+export declare function isInBooleanContext(node: AST.AnyNode): boolean;
+//# sourceMappingURL=isInBooleanContext.d.ts.map

package/lib/rules/utils/isInBooleanContext.js

@@ -0,0 +1,22 @@
+import ts from "typescript";
+//#region src/rules/utils/isInBooleanContext.ts
+function isInBooleanContext(node) {
+	switch (node.parent.kind) {
+		case ts.SyntaxKind.AsExpression:
+		case ts.SyntaxKind.NonNullExpression:
+		case ts.SyntaxKind.ParenthesizedExpression: return isInBooleanContext(node.parent);
+		case ts.SyntaxKind.BinaryExpression: return node.parent.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken || node.parent.operatorToken.kind === ts.SyntaxKind.BarBarToken;
+		case ts.SyntaxKind.CallExpression: return ts.isIdentifier(node.parent.expression) && node.parent.expression.text === "Boolean" && node.parent.arguments.length === 1 && node.parent.arguments[0] === node;
+		case ts.SyntaxKind.ConditionalExpression:
+		case ts.SyntaxKind.ForStatement: return node.parent.condition === node;
+		case ts.SyntaxKind.DoStatement:
+		case ts.SyntaxKind.IfStatement:
+		case ts.SyntaxKind.WhileStatement: return node.parent.expression === node;
+		case ts.SyntaxKind.PrefixUnaryExpression: return node.parent.operator === ts.SyntaxKind.ExclamationToken;
+		default: return false;
+	}
+}
+//#endregion
+export { isInBooleanContext };
+
+//# sourceMappingURL=isInBooleanContext.js.map

package/lib/rules/utils/isTypeRecursive.d.ts

@@ -1,3 +1,3 @@
-import * as ts from "typescript";
+import type * as ts from "typescript";
 export declare function isTypeRecursive(type: ts.Type, predicate: (t: ts.Type) => boolean): boolean;
 //# sourceMappingURL=isTypeRecursive.d.ts.map

package/lib/rules/utils/isTypeRecursive.js

@@ -1,6 +1,8 @@
-export function isTypeRecursive(type, predicate) {
-    return type.isUnionOrIntersection()
-        ? type.types.some((subType) => isTypeRecursive(subType, predicate))
-        : predicate(type);
+//#region src/rules/utils/isTypeRecursive.ts
+function isTypeRecursive(type, predicate) {
+	return type.isUnionOrIntersection() ? type.types.some((subType) => isTypeRecursive(subType, predicate)) : predicate(type);
 }
+//#endregion
+export { isTypeRecursive };
+
 //# sourceMappingURL=isTypeRecursive.js.map

package/lib/rules/utils/isUnsafeAssignment.d.ts

@@ -1,4 +1,5 @@
-import * as ts from "typescript";
+import type { AST } from "@flint.fyi/typescript-language";
+import ts from "typescript";
 /**
  * Does a simple check to see if there is an any being assigned to a non-any type.
  *
@@ -7,7 +8,7 @@ import * as ts from "typescript";
  * @example See tests for examples
  * @returns false if it's safe, or an object with the two types if it's unsafe
  */
-export declare function isUnsafeAssignment(type: ts.Type, receiver: ts.Type, checker: ts.TypeChecker, senderNode: null | ts.Node): false | {
+export declare function isUnsafeAssignment(type: ts.Type, receiver: ts.Type, senderNode: AST.Expression): false | {
     receiver: ts.Type;
     sender: ts.Type;
 };