@flint.fyi/ts 0.20.0 → 0.21.0

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

package/lib/rules/multilineAmbiguities.d.ts

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

package/lib/rules/multilineAmbiguities.js

@@ -60,5 +60,3 @@ function getLineEndPosition(lineNumber, sourceFile) {
 }
 //#endregion
 export { multilineAmbiguities_default as default };
-
-//# sourceMappingURL=multilineAmbiguities.js.map

package/lib/rules/namedDefaultExports.d.ts

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

package/lib/rules/namedDefaultExports.js

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

package/lib/rules/namespaceDeclarations.d.ts

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

package/lib/rules/namespaceDeclarations.js

@@ -2,7 +2,7 @@ import { ruleCreator } from "./ruleCreator.js";
 import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
 import { SyntaxKind } from "typescript";
 import * as tsutils from "ts-api-utils";
-import { z } from "zod/v4";
+import { z as z$1 } from "zod/v4";
 //#region src/rules/namespaceDeclarations.ts
 var namespaceDeclarations_default = ruleCreator.createRule(typescriptLanguage, {
 	about: {
@@ -16,8 +16,8 @@ var namespaceDeclarations_default = ruleCreator.createRule(typescriptLanguage, {
 		suggestions: ["Modern codebases generally use `export` and `import` statements to define and use ECMAScript modules instead."]
 	} },
 	options: {
-		allowDeclarations: z.boolean().default(false).describe("Whether to allow namespaces declared with the `declare` keyword."),
-		allowDefinitionFiles: z.boolean().default(false).describe("Whether to allow namespaces in `.d.ts` and other definition files.")
+		allowDeclarations: z$1.boolean().default(false).describe("Whether to allow namespaces declared with the `declare` keyword."),
+		allowDefinitionFiles: z$1.boolean().default(false).describe("Whether to allow namespaces in `.d.ts` and other definition files.")
 	},
 	setup(context) {
 		return { visitors: { ModuleDeclaration: (node, { options: { allowDeclarations, allowDefinitionFiles }, sourceFile }) => {
@@ -33,5 +33,3 @@ var namespaceDeclarations_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { namespaceDeclarations_default as default };
-
-//# sourceMappingURL=namespaceDeclarations.js.map

package/lib/rules/namespaceImplicitAmbientImports.d.ts

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

package/lib/rules/namespaceImplicitAmbientImports.js

@@ -36,5 +36,3 @@ var namespaceImplicitAmbientImports_default = ruleCreator.createRule(typescriptL
 });
 //#endregion
 export { namespaceImplicitAmbientImports_default as default };
-
-//# sourceMappingURL=namespaceImplicitAmbientImports.js.map

package/lib/rules/namespaceKeywords.d.ts

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

package/lib/rules/namespaceKeywords.js

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

package/lib/rules/nativeObjectExtensions.d.ts

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

package/lib/rules/nativeObjectExtensions.js

@@ -2,7 +2,7 @@ import { ruleCreator } from "./ruleCreator.js";
 import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
 import * as ts$1 from "typescript";
 //#region src/rules/nativeObjectExtensions.ts
-const nativeConstructors = new Set([
+const nativeConstructors = /* @__PURE__ */ new Set([
 	"AggregateError",
 	"Array",
 	"ArrayBuffer",
@@ -70,17 +70,17 @@ var nativeObjectExtensions_default = ruleCreator.createRule(typescriptLanguage,
 		suggestions: ["Create a wrapper class or utility function instead of extending the prototype.", "Use composition rather than modifying the prototype chain."]
 	} },
 	setup(context) {
-		function checkNode(node, { sourceFile, typeChecker }) {
+		function checkNode(node, { program, sourceFile, typeChecker }) {
 			if (!isPrototypeAccess(node)) return;
 			const objectIdentifier = getPrototypeObject(node);
 			if (!objectIdentifier) return;
 			const name = objectIdentifier.text;
-			if (!nativeConstructors.has(name) || !isGlobalDeclarationOfName(objectIdentifier, name, typeChecker)) return;
+			if (!nativeConstructors.has(name) || !isGlobalDeclarationOfName(objectIdentifier, name, typeChecker, program)) return;
 			switch (node.parent.kind) {
 				case ts$1.SyntaxKind.CallExpression: {
 					if (node.parent.arguments[0] !== node) break;
 					const callee = node.parent.expression;
-					if (!ts$1.isPropertyAccessExpression(callee) || !ts$1.isIdentifier(callee.expression) || callee.expression.text !== "Object" || callee.name.text !== "defineProperty" && callee.name.text !== "defineProperties" || !isGlobalDeclarationOfName(callee.expression, "Object", typeChecker)) break;
+					if (!ts$1.isPropertyAccessExpression(callee) || !ts$1.isIdentifier(callee.expression) || callee.expression.text !== "Object" || callee.name.text !== "defineProperty" && callee.name.text !== "defineProperties" || !isGlobalDeclarationOfName(callee.expression, "Object", typeChecker, program)) break;
 					context.report({
 						data: { name },
 						message: "noExtendNative",
@@ -110,5 +110,3 @@ var nativeObjectExtensions_default = ruleCreator.createRule(typescriptLanguage,
 });
 //#endregion
 export { nativeObjectExtensions_default as default };
-
-//# sourceMappingURL=nativeObjectExtensions.js.map

package/lib/rules/negativeIndexLengthMethods.d.ts

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