@flint.fyi/ts 0.19.1 → 0.21.0

package/lib/rules/generatorFunctionYields.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "missingYield", undefined>;
 export default _default;
-//# sourceMappingURL=generatorFunctionYields.d.ts.map

package/lib/rules/generatorFunctionYields.js

@@ -46,5 +46,3 @@ function blockContainsYield(block) {
 }
 //#endregion
 export { generatorFunctionYields_default as default };
-
-//# sourceMappingURL=generatorFunctionYields.js.map

package/lib/rules/getterReturns.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "missingReturn", undefined>;
 export default _default;
-//# sourceMappingURL=getterReturns.d.ts.map

package/lib/rules/getterReturns.js

@@ -61,5 +61,3 @@ function tryStatementReturnsValue(statement) {
 }
 //#endregion
 export { getterReturns_default as default };
-
-//# sourceMappingURL=getterReturns.js.map

package/lib/rules/globalAssignments.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "noGlobalAssign", undefined>;
 export default _default;
-//# sourceMappingURL=globalAssignments.d.ts.map

package/lib/rules/globalAssignments.js

@@ -20,20 +20,20 @@ var globalAssignments_default = ruleCreator.createRule(typescriptLanguage, {
 	} },
 	setup(context) {
 		return { visitors: {
-			BinaryExpression: (node, { sourceFile, typeChecker }) => {
-				if (tsutils.isAssignmentKind(node.operatorToken.kind) && isGlobalVariable(node.left, typeChecker)) context.report({
+			BinaryExpression: (node, { program, sourceFile, typeChecker }) => {
+				if (tsutils.isAssignmentKind(node.operatorToken.kind) && isGlobalVariable(node.left, typeChecker, program)) context.report({
 					message: "noGlobalAssign",
 					range: getTSNodeRange(node.left, sourceFile)
 				});
 			},
-			PostfixUnaryExpression: (node, { sourceFile, typeChecker }) => {
-				if (isGlobalVariable(node.operand, typeChecker)) context.report({
+			PostfixUnaryExpression: (node, { program, sourceFile, typeChecker }) => {
+				if (isGlobalVariable(node.operand, typeChecker, program)) 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({
+			PrefixUnaryExpression: (node, { program, sourceFile, typeChecker }) => {
+				if ((node.operator === SyntaxKind.PlusPlusToken || node.operator === SyntaxKind.MinusMinusToken) && isGlobalVariable(node.operand, typeChecker, program)) context.report({
 					message: "noGlobalAssign",
 					range: getTSNodeRange(node.operand, sourceFile)
 				});
@@ -43,5 +43,3 @@ var globalAssignments_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { globalAssignments_default as default };
-
-//# sourceMappingURL=globalAssignments.js.map

package/lib/rules/globalObjectCalls.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "noGlobalObjectCall", undefined>;
 export default _default;
-//# sourceMappingURL=globalObjectCalls.d.ts.map

package/lib/rules/globalObjectCalls.js

@@ -2,7 +2,7 @@ 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([
+const globalObjects = /* @__PURE__ */ new Set([
 	"Atomics",
 	"JSON",
 	"Math",
@@ -38,5 +38,3 @@ var globalObjectCalls_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { globalObjectCalls_default as default };
-
-//# sourceMappingURL=globalObjectCalls.js.map

package/lib/rules/globalThisAliases.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "preferGlobalThis", undefined>;
 export default _default;
-//# sourceMappingURL=globalThisAliases.d.ts.map

package/lib/rules/globalThisAliases.js

@@ -1,24 +1,24 @@
 import { ruleCreator } from "./ruleCreator.js";
 import { declarationIncludesGlobal, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
+import { isPropertyAccessExpression, isShorthandPropertyAssignment } from "typescript";
 //#region src/rules/globalThisAliases.ts
-const globalAliases = new Set([
+const globalAliases = /* @__PURE__ */ new Set([
 	"global",
 	"self",
 	"window"
 ]);
-function isOnlyGlobalDeclaration(node, typeChecker) {
+function isOnlyGlobalDeclaration(node, typeChecker, program) {
 	const symbol = typeChecker.getSymbolAtLocation(node);
 	if (!symbol) return false;
 	const declarations = symbol.getDeclarations();
 	if (!declarations?.length) return false;
-	return declarations.every(declarationIncludesGlobal);
+	return declarations.every((declaration) => declarationIncludesGlobal(declaration, program));
 }
 function isPropertyAccess(node) {
-	return ts.isPropertyAccessExpression(node.parent) && node.parent.name === node;
+	return isPropertyAccessExpression(node.parent) && node.parent.name === node;
 }
 function isPropertyShorthand(node) {
-	return ts.isShorthandPropertyAssignment(node.parent) && node.parent.name === node;
+	return isShorthandPropertyAssignment(node.parent) && node.parent.name === node;
 }
 var globalThisAliases_default = ruleCreator.createRule(typescriptLanguage, {
 	about: {
@@ -32,8 +32,8 @@ var globalThisAliases_default = ruleCreator.createRule(typescriptLanguage, {
 		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({
+		return { visitors: { Identifier: (node, { program, sourceFile, typeChecker }) => {
+			if (globalAliases.has(node.text) && !isPropertyAccess(node) && !isPropertyShorthand(node) && isOnlyGlobalDeclaration(node, typeChecker, program)) context.report({
 				data: { name: node.text },
 				message: "preferGlobalThis",
 				range: getTSNodeRange(node, sourceFile)
@@ -43,5 +43,3 @@ var globalThisAliases_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { globalThisAliases_default as default };
-
-//# sourceMappingURL=globalThisAliases.js.map

package/lib/rules/impliedEvals.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "functionConstructor" | "impliedEval", undefined>;
 export default _default;
-//# sourceMappingURL=impliedEvals.d.ts.map

package/lib/rules/impliedEvals.js

@@ -1,15 +1,15 @@
 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 { SignatureKind, SymbolFlags, SyntaxKind, TypeFlags, isElementAccessExpression, isIdentifier, isPropertyAccessExpression, isStringLiteral } from "typescript";
 import * as tsutils from "ts-api-utils";
 //#region src/rules/impliedEvals.ts
-const globalCandidates = new Set([
+const globalCandidates = /* @__PURE__ */ new Set([
 	"global",
 	"globalThis",
 	"window"
 ]);
-const evalLikeFunctions = new Set([
+const evalLikeFunctions = /* @__PURE__ */ new Set([
 	"execScript",
 	"setImmediate",
 	"setInterval",
@@ -17,55 +17,55 @@ const evalLikeFunctions = new Set([
 ]);
 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;
+		case SyntaxKind.ElementAccessExpression:
+			if (isIdentifier(node.expression) && globalCandidates.has(node.expression.text) && 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;
+		case SyntaxKind.Identifier: return node.text;
+		case SyntaxKind.PropertyAccessExpression:
+			if (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);
+		case SyntaxKind.Identifier: return node.text === "bind";
+		case 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 (tsutils.isTypeFlagSet(type, TypeFlags.Any | TypeFlags.Unknown | TypeFlags.Never)) return false;
 	if (type.isUnion()) return type.types.every(isDefinitelyString);
-	return tsutils.isTypeFlagSet(type, ts$1.TypeFlags.StringLike);
+	return tsutils.isTypeFlagSet(type, 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:
+		case SyntaxKind.ArrowFunction:
+		case SyntaxKind.FunctionDeclaration:
+		case SyntaxKind.FunctionExpression: return true;
+		case 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;
+		case SyntaxKind.NoSubstitutionTemplateLiteral:
+		case SyntaxKind.StringLiteral:
+		case 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;
+	if (tsutils.isTypeFlagSet(type, TypeFlags.Any | 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;
+	if (symbol && tsutils.isSymbolFlagSet(symbol, SymbolFlags.Function | SymbolFlags.Method)) return true;
+	return !!typeChecker.getSignaturesOfType(type, SignatureKind.Call).length;
 }
-function isReferenceToGlobalFunction(node, typeChecker) {
-	if (ts$1.isPropertyAccessExpression(node.expression) || ts$1.isElementAccessExpression(node.expression)) return true;
+function isReferenceToGlobalFunction(node, typeChecker, program) {
+	if (isPropertyAccessExpression(node.expression) || 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);
+		return program.isSourceFileDefaultLibrary(sourceFile) || sourceFile.fileName.includes("node_modules/@types/node/") || /\/lib\.[^/]*\.d\.ts$/.test(sourceFile.fileName);
 	});
 }
 var impliedEvals_default = ruleCreator.createRule(typescriptLanguage, {
@@ -99,7 +99,7 @@ var impliedEvals_default = ruleCreator.createRule(typescriptLanguage, {
 			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;
+			if (!evalLikeFunctions.has(calleeName) || isFunction$1(handler, typeChecker, program) || !isReferenceToGlobalFunction(node, typeChecker, program)) return;
 			context.report({
 				data: { name: calleeName },
 				message: "impliedEval",
@@ -126,5 +126,3 @@ var impliedEvals_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { impliedEvals_default as default };
-
-//# sourceMappingURL=impliedEvals.js.map

package/lib/rules/importEmptyBlocks.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "noEmptyNamedBlocksOnly" | "noEmptyNamedBlocksWithOther", undefined>;
 export default _default;
-//# sourceMappingURL=importEmptyBlocks.d.ts.map

package/lib/rules/importEmptyBlocks.js

@@ -49,5 +49,3 @@ var importEmptyBlocks_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { importEmptyBlocks_default as default };
-
-//# sourceMappingURL=importEmptyBlocks.js.map

package/lib/rules/importTypeSideEffects.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "useTopLevelQualifier", undefined>;
 export default _default;
-//# sourceMappingURL=importTypeSideEffects.d.ts.map

package/lib/rules/importTypeSideEffects.js

@@ -27,5 +27,3 @@ var importTypeSideEffects_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { importTypeSideEffects_default as default };
-
-//# sourceMappingURL=importTypeSideEffects.js.map

package/lib/rules/indexedObjectTypes.d.ts

@@ -13,4 +13,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     }>>;
 }>;
 export default _default;
-//# sourceMappingURL=indexedObjectTypes.d.ts.map

package/lib/rules/indexedObjectTypes.js

@@ -1,7 +1,7 @@
 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";
+import { z as z$1 } from "zod/v4";
 //#region src/rules/indexedObjectTypes.ts
 function getSingleIndexSignature(members) {
 	if (members.length !== 1) return;
@@ -49,7 +49,7 @@ var indexedObjectTypes_default = ruleCreator.createRule(typescriptLanguage, {
 			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 }`.") },
+	options: { style: z$1.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);
@@ -68,8 +68,8 @@ var indexedObjectTypes_default = ruleCreator.createRule(typescriptLanguage, {
 			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({
+			TypeReference: (node, { options, program, sourceFile, typeChecker }) => {
+				if (options.style === "index-signature" && node.typeName.kind === ts$1.SyntaxKind.Identifier && node.typeName.text === "Record" && isGlobalDeclaration(node.typeName, typeChecker, program) && node.typeArguments?.length === 2) context.report({
 					message: "preferIndexSignature",
 					range: getTSNodeRange(node, sourceFile)
 				});
@@ -79,5 +79,3 @@ var indexedObjectTypes_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { indexedObjectTypes_default as default };
-
-//# sourceMappingURL=indexedObjectTypes.js.map

package/lib/rules/instanceOfArrays.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "useArrayIsArray", undefined>;
 export default _default;
-//# sourceMappingURL=instanceOfArrays.d.ts.map

package/lib/rules/instanceOfArrays.js

@@ -14,10 +14,10 @@ var instanceOfArrays_default = ruleCreator.createRule(typescriptLanguage, {
 		suggestions: ["Use `Array.isArray(value)` for reliable array detection."]
 	} },
 	setup(context) {
-		return { visitors: { BinaryExpression: (node, { sourceFile, typeChecker }) => {
+		return { visitors: { BinaryExpression: (node, { program, 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;
+			if (right.kind !== SyntaxKind.Identifier || right.text !== "Array" || !isGlobalDeclarationOfName(right, "Array", typeChecker, program)) return;
 			context.report({
 				message: "useArrayIsArray",
 				range: getTSNodeRange(node, sourceFile)
@@ -27,5 +27,3 @@ var instanceOfArrays_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { instanceOfArrays_default as default };
-
-//# sourceMappingURL=instanceOfArrays.js.map

package/lib/rules/irregularWhitespaces.d.ts

@@ -13,4 +13,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     skipTemplates: z.ZodDefault<z.ZodBoolean>;
 }>;
 export default _default;
-//# sourceMappingURL=irregularWhitespaces.d.ts.map

package/lib/rules/irregularWhitespaces.js

@@ -1,7 +1,7 @@
 import { ruleCreator } from "./ruleCreator.js";
 import { typescriptLanguage } from "@flint.fyi/typescript-language";
 import * as ts$1 from "typescript";
-import { z } from "zod/v4";
+import { z as z$1 } 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;
@@ -32,10 +32,10 @@ var irregularWhitespaces_default = ruleCreator.createRule(typescriptLanguage, {
 		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.")
+		skipComments: z$1.boolean().default(false).describe("Whether to allow irregular whitespace in comments."),
+		skipJSXText: z$1.boolean().default(false).describe("Whether to allow irregular whitespace in JSX text content."),
+		skipRegularExpressions: z$1.boolean().default(false).describe("Whether to allow irregular whitespace in regular expression literals."),
+		skipTemplates: z$1.boolean().default(false).describe("Whether to allow irregular whitespace in template literals.")
 	},
 	setup(context) {
 		return { visitors: { SourceFile: (node, { options, sourceFile }) => {
@@ -93,5 +93,3 @@ var irregularWhitespaces_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { irregularWhitespaces_default as default };
-
-//# sourceMappingURL=irregularWhitespaces.js.map

package/lib/rules/isNaNComparisons.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "useIsNaN", undefined>;
 export default _default;
-//# sourceMappingURL=isNaNComparisons.d.ts.map

package/lib/rules/isNaNComparisons.js

@@ -2,7 +2,7 @@ import { ruleCreator } from "./ruleCreator.js";
 import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage, unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
 import { SyntaxKind } from "typescript";
 //#region src/rules/isNaNComparisons.ts
-const comparisonOperators = new Set([
+const comparisonOperators = /* @__PURE__ */ new Set([
 	SyntaxKind.EqualsEqualsEqualsToken,
 	SyntaxKind.EqualsEqualsToken,
 	SyntaxKind.ExclamationEqualsEqualsToken,
@@ -24,20 +24,18 @@ var isNaNComparisons_default = ruleCreator.createRule(typescriptLanguage, {
 		suggestions: ["Use `Number.isNaN(value)` for reliable NaN detection."]
 	} },
 	setup(context) {
-		return { visitors: { BinaryExpression: (node, { sourceFile, typeChecker }) => {
+		return { visitors: { BinaryExpression: (node, { program, sourceFile, typeChecker }) => {
 			if (!comparisonOperators.has(node.operatorToken.kind)) return;
-			if (isNaNIdentifier(node.left, typeChecker) || isNaNIdentifier(node.right, typeChecker)) context.report({
+			if (isNaNIdentifier(node.left, typeChecker, program) || isNaNIdentifier(node.right, typeChecker, program)) context.report({
 				message: "useIsNaN",
 				range: getTSNodeRange(node, sourceFile)
 			});
 		} } };
-		function isNaNIdentifier(node, typeChecker) {
+		function isNaNIdentifier(node, typeChecker, program) {
 			const unwrapped = unwrapParenthesizedNode(node);
-			return unwrapped.kind === SyntaxKind.Identifier && unwrapped.text === "NaN" && isGlobalDeclarationOfName(unwrapped, "NaN", typeChecker);
+			return unwrapped.kind === SyntaxKind.Identifier && unwrapped.text === "NaN" && isGlobalDeclarationOfName(unwrapped, "NaN", typeChecker, program);
 		}
 	}
 });
 //#endregion
 export { isNaNComparisons_default as default };
-
-//# sourceMappingURL=isNaNComparisons.js.map

package/lib/rules/literalConstructorWrappers.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "preferLiteral", undefined>;
 export default _default;
-//# sourceMappingURL=literalConstructorWrappers.d.ts.map

package/lib/rules/literalConstructorWrappers.js

@@ -1,27 +1,27 @@
 import { ruleCreator } from "./ruleCreator.js";
 import { isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
+import { SyntaxKind, isBigIntLiteral, isIdentifier, isLiteralExpression, isNumericLiteral, isStringLiteral } from "typescript";
 //#region src/rules/literalConstructorWrappers.ts
-const literalConstructors = new Set([
+const literalConstructors = /* @__PURE__ */ new Set([
 	"BigInt",
 	"Boolean",
 	"Number",
 	"String"
 ]);
 function isBooleanLiteral(node) {
-	return node.kind === ts$1.SyntaxKind.TrueKeyword || node.kind === ts$1.SyntaxKind.FalseKeyword;
+	return node.kind === SyntaxKind.TrueKeyword || node.kind === SyntaxKind.FalseKeyword;
 }
 function isLiteralArgument(node, constructorName) {
 	switch (constructorName) {
 		case "BigInt": return isNumericLiteralForBigInt(node);
-		case "Boolean": return ts$1.isLiteralExpression(node) || isBooleanLiteral(node);
-		case "Number": return ts$1.isStringLiteral(node) && isValidNumericString(node.text);
-		case "String": return ts$1.isNumericLiteral(node) || isBooleanLiteral(node) || ts$1.isBigIntLiteral(node);
+		case "Boolean": return isLiteralExpression(node) || isBooleanLiteral(node);
+		case "Number": return isStringLiteral(node) && isValidNumericString(node.text);
+		case "String": return isNumericLiteral(node) || isBooleanLiteral(node) || isBigIntLiteral(node);
 		default: return false;
 	}
 }
 function isNumericLiteralForBigInt(node) {
-	return node.kind === ts$1.SyntaxKind.NumericLiteral && /^-?\d+$/.test(node.text);
+	return node.kind === SyntaxKind.NumericLiteral && /^-?\d+$/.test(node.text);
 }
 function isValidNumericString(value) {
 	const trimmed = value.trim();
@@ -41,10 +41,10 @@ var literalConstructorWrappers_default = ruleCreator.createRule(typescriptLangua
 		suggestions: ["Use literal syntax instead of `{{ name }}()`."]
 	} },
 	setup(context) {
-		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
-			if (!ts$1.isIdentifier(node.expression)) return;
+		return { visitors: { CallExpression: (node, { program, sourceFile, typeChecker }) => {
+			if (!isIdentifier(node.expression)) return;
 			const name = node.expression.text;
-			if (!literalConstructors.has(name) || node.arguments.length !== 1 || !isGlobalDeclarationOfName(node.expression, name, typeChecker)) return;
+			if (!literalConstructors.has(name) || node.arguments.length !== 1 || !isGlobalDeclarationOfName(node.expression, name, typeChecker, program)) return;
 			const argument = node.arguments[0];
 			if (!isLiteralArgument(argument, name)) return;
 			context.report({
@@ -60,5 +60,3 @@ var literalConstructorWrappers_default = ruleCreator.createRule(typescriptLangua
 });
 //#endregion
 export { literalConstructorWrappers_default as default };
-
-//# sourceMappingURL=literalConstructorWrappers.js.map

package/lib/rules/mathMethods.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "preferModernMath", undefined>;
 export default _default;
-//# sourceMappingURL=mathMethods.d.ts.map

package/lib/rules/mathMethods.js

@@ -3,24 +3,24 @@ import { skipParentheses } from "./utils/skipParentheses.js";
 import { getTSNodeRange, hasSameTokens, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
 import { SyntaxKind } from "typescript";
 //#region src/rules/mathMethods.ts
-function checkLogDivideConstant(node, typeChecker, constantName, replacementMethod) {
+function checkLogDivideConstant(node, typeChecker, program, constantName, replacementMethod) {
 	if (node.operatorToken.kind !== SyntaxKind.SlashToken) return;
 	const left = skipParentheses(node.left);
 	const right = skipParentheses(node.right);
-	if (getMathMethodArgument(left, "log", typeChecker) && isMathProperty(right, constantName, typeChecker)) return {
+	if (getMathMethodArgument(left, "log", typeChecker, program) && isMathProperty(right, constantName, typeChecker, program)) return {
 		description: `Math.log(…) / Math.${constantName}`,
 		replacement: `Math.${replacementMethod}(…)`
 	};
 }
-function checkLogTimesConstant(node, typeChecker, constantName, replacementMethod) {
+function checkLogTimesConstant(node, typeChecker, program, constantName, replacementMethod) {
 	if (node.operatorToken.kind !== SyntaxKind.AsteriskToken) return;
 	const left = skipParentheses(node.left);
 	const right = skipParentheses(node.right);
-	if (getMathMethodArgument(left, "log", typeChecker) && isMathProperty(right, constantName, typeChecker)) return {
+	if (getMathMethodArgument(left, "log", typeChecker, program) && isMathProperty(right, constantName, typeChecker, program)) return {
 		description: `Math.log(…) * Math.${constantName}`,
 		replacement: `Math.${replacementMethod}(…)`
 	};
-	if (isMathProperty(left, constantName, typeChecker) && getMathMethodArgument(right, "log", typeChecker)) return {
+	if (isMathProperty(left, constantName, typeChecker, program) && getMathMethodArgument(right, "log", typeChecker, program)) return {
 		description: `Math.${constantName} * Math.log(…)`,
 		replacement: `Math.${replacementMethod}(…)`
 	};
@@ -30,14 +30,14 @@ function flattenPlusExpression(node) {
 	if (unwrapped.kind === SyntaxKind.BinaryExpression && unwrapped.operatorToken.kind === SyntaxKind.PlusToken) return [...flattenPlusExpression(unwrapped.left), ...flattenPlusExpression(unwrapped.right)];
 	return [unwrapped];
 }
-function getMathMethodArgument(node, methodName, typeChecker) {
+function getMathMethodArgument(node, methodName, typeChecker, program) {
 	if (node.kind !== SyntaxKind.CallExpression || node.questionDotToken || node.arguments.length !== 1) return false;
 	const argument = node.arguments[0];
-	if (argument.kind === SyntaxKind.SpreadElement || !isMathProperty(node.expression, methodName, typeChecker)) return;
+	if (argument.kind === SyntaxKind.SpreadElement || !isMathProperty(node.expression, methodName, typeChecker, program)) return;
 	return argument;
 }
-function isMathProperty(node, propertyName, typeChecker) {
-	return node.kind === SyntaxKind.PropertyAccessExpression && !node.questionDotToken && node.name.kind === SyntaxKind.Identifier && node.name.text === propertyName && node.expression.kind === SyntaxKind.Identifier && isGlobalDeclarationOfName(node.expression, "Math", typeChecker);
+function isMathProperty(node, propertyName, typeChecker, program) {
+	return node.kind === SyntaxKind.PropertyAccessExpression && !node.questionDotToken && node.name.kind === SyntaxKind.Identifier && node.name.text === propertyName && node.expression.kind === SyntaxKind.Identifier && isGlobalDeclarationOfName(node.expression, "Math", typeChecker, program);
 }
 function isPowerTwoExpression(node, sourceFile) {
 	const unwrapped = skipParentheses(node);
@@ -62,7 +62,7 @@ var mathMethods_default = ruleCreator.createRule(typescriptLanguage, {
 	} },
 	setup(context) {
 		return { visitors: {
-			BinaryExpression: (node, { sourceFile, typeChecker }) => {
+			BinaryExpression: (node, { program, sourceFile, typeChecker }) => {
 				for (const { constantName, replacementMethod } of [{
 					constantName: "LOG10E",
 					replacementMethod: "log10"
@@ -70,7 +70,7 @@ var mathMethods_default = ruleCreator.createRule(typescriptLanguage, {
 					constantName: "LOG2E",
 					replacementMethod: "log2"
 				}]) {
-					const match = checkLogTimesConstant(node, typeChecker, constantName, replacementMethod);
+					const match = checkLogTimesConstant(node, typeChecker, program, constantName, replacementMethod);
 					if (match) {
 						context.report({
 							data: {
@@ -90,7 +90,7 @@ var mathMethods_default = ruleCreator.createRule(typescriptLanguage, {
 					constantName: "LN2",
 					replacementMethod: "log2"
 				}]) {
-					const match = checkLogDivideConstant(node, typeChecker, constantName, replacementMethod);
+					const match = checkLogDivideConstant(node, typeChecker, program, constantName, replacementMethod);
 					if (match) {
 						context.report({
 							data: {
@@ -104,8 +104,8 @@ var mathMethods_default = ruleCreator.createRule(typescriptLanguage, {
 					}
 				}
 			},
-			CallExpression: (node, { sourceFile, typeChecker }) => {
-				const argument = getMathMethodArgument(node, "sqrt", typeChecker);
+			CallExpression: (node, { program, sourceFile, typeChecker }) => {
+				const argument = getMathMethodArgument(node, "sqrt", typeChecker, program);
 				if (!argument) return;
 				const expressions = flattenPlusExpression(argument);
 				if (!expressions.every((expr) => isPowerTwoExpression(expr, sourceFile))) return;
@@ -124,5 +124,3 @@ var mathMethods_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { mathMethods_default as default };
-
-//# sourceMappingURL=mathMethods.js.map

package/lib/rules/meaninglessVoidOperators.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "meaninglessVoid", undefined>;
 export default _default;
-//# sourceMappingURL=meaninglessVoidOperators.d.ts.map

package/lib/rules/meaninglessVoidOperators.js

@@ -35,5 +35,3 @@ var meaninglessVoidOperators_default = ruleCreator.createRule(typescriptLanguage
 });
 //#endregion
 export { meaninglessVoidOperators_default as default };
-
-//# sourceMappingURL=meaninglessVoidOperators.js.map

package/lib/rules/misleadingVoidExpressions.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "voidExpressionArrow" | "voidExpressionReturn" | "voidExpressionValue", undefined>;
 export default _default;
-//# sourceMappingURL=misleadingVoidExpressions.d.ts.map

package/lib/rules/misleadingVoidExpressions.js

@@ -124,5 +124,3 @@ var misleadingVoidExpressions_default = ruleCreator.createRule(typescriptLanguag
 });
 //#endregion
 export { misleadingVoidExpressions_default as default };
-
-//# sourceMappingURL=misleadingVoidExpressions.js.map

package/lib/rules/moduleSpecifierLists.d.ts

@@ -7,4 +7,3 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly url: string;
 }, "emptyExportSpecifiers" | "emptyImportSpecifiers", undefined>;
 export default _default;
-//# sourceMappingURL=moduleSpecifierLists.d.ts.map

package/lib/rules/moduleSpecifierLists.js

@@ -88,5 +88,3 @@ var moduleSpecifierLists_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { moduleSpecifierLists_default as default };
-
-//# sourceMappingURL=moduleSpecifierLists.js.map