@flint.fyi/ts 0.19.1 → 0.21.0

package/lib/rules/arraySomeMethods.js

@@ -73,5 +73,3 @@ function isNonZeroLengthCheck(node) {
 }
 //#endregion
 export { arraySomeMethods_default as default };
-
-//# sourceMappingURL=arraySomeMethods.js.map

package/lib/rules/arrayTernarySpreadingConsistency.d.ts

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

package/lib/rules/arrayTernarySpreadingConsistency.js

@@ -70,5 +70,3 @@ function unwrapParentheses(node) {
 }
 //#endregion
 export { arrayTernarySpreadingConsistency_default as default };
-
-//# sourceMappingURL=arrayTernarySpreadingConsistency.js.map

package/lib/rules/arrayTypes.d.ts

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

package/lib/rules/arrayTypes.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/arrayTypes.ts
 function isSimpleType(typeNode) {
 	switch (typeNode?.kind) {
@@ -49,7 +49,7 @@ var arrayTypes_default = ruleCreator.createRule(typescriptLanguage, {
 			suggestions: ["Replace `readonly T[]` with `ReadonlyArray<T>`."]
 		}
 	},
-	options: { style: z.enum([
+	options: { style: z$1.enum([
 		"array",
 		"array-simple",
 		"generic"
@@ -85,8 +85,8 @@ var arrayTypes_default = ruleCreator.createRule(typescriptLanguage, {
 					range: getTSNodeRange(node, sourceFile)
 				});
 			},
-			TypeReference: (node, { options, sourceFile, typeChecker }) => {
-				if (node.typeName.kind !== ts$1.SyntaxKind.Identifier || !isGlobalDeclaration(node.typeName, typeChecker)) return;
+			TypeReference: (node, { options, program, sourceFile, typeChecker }) => {
+				if (node.typeName.kind !== ts$1.SyntaxKind.Identifier || !isGlobalDeclaration(node.typeName, typeChecker, program)) return;
 				const typeName = node.typeName.text;
 				if (typeName !== "Array" && typeName !== "ReadonlyArray") return;
 				const typeArg = node.typeArguments?.[0];
@@ -107,5 +107,3 @@ var arrayTypes_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { arrayTypes_default as default };
-
-//# sourceMappingURL=arrayTypes.js.map

package/lib/rules/arrayUnnecessaryLengthChecks.d.ts

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

package/lib/rules/arrayUnnecessaryLengthChecks.js

@@ -93,5 +93,3 @@ var arrayUnnecessaryLengthChecks_default = ruleCreator.createRule(typescriptLang
 });
 //#endregion
 export { arrayUnnecessaryLengthChecks_default as default };
-
-//# sourceMappingURL=arrayUnnecessaryLengthChecks.js.map

package/lib/rules/asConstAssertions.d.ts

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

package/lib/rules/asConstAssertions.js

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

package/lib/rules/assignmentOperatorShorthands.d.ts

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

package/lib/rules/assignmentOperatorShorthands.js

@@ -43,5 +43,3 @@ var assignmentOperatorShorthands_default = ruleCreator.createRule(typescriptLang
 });
 //#endregion
 export { assignmentOperatorShorthands_default as default };
-
-//# sourceMappingURL=assignmentOperatorShorthands.js.map

package/lib/rules/asyncFunctionAwaits.d.ts

@@ -0,0 +1,9 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports async functions that do not use await.";
+    readonly id: "asyncFunctionAwaits";
+    readonly presets: readonly ["logicalStrict"];
+} & {
+    readonly pluginId: string;
+    readonly url: string;
+}, "missingAwait", undefined>;
+export default _default;

package/lib/rules/asyncFunctionAwaits.js

@@ -0,0 +1,53 @@
+import { ruleCreator } from "./ruleCreator.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/asyncFunctionAwaits.ts
+var asyncFunctionAwaits_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports async functions that do not use await.",
+		id: "asyncFunctionAwaits",
+		presets: ["logicalStrict"]
+	},
+	messages: { missingAwait: {
+		primary: "This function is marked `async` but does not contain an `await` expression or return a Promise.",
+		secondary: ["Async functions always wrap their return value in a Promise, which adds overhead if you're not using await.", "This may indicate incomplete implementation or leftover code after refactoring."],
+		suggestions: ["Add an `await` expression if you need to wait for asynchronous operations.", "Remove the `async` keyword if the function doesn't need to be asynchronous."]
+	} },
+	setup(context) {
+		function checkFunction(node, { sourceFile, typeChecker }) {
+			const asyncModifier = node.modifiers?.find((modifier) => modifier.kind === ts$1.SyntaxKind.AsyncKeyword);
+			if (!asyncModifier || node.asteriskToken || !node.body || isEmptyBody(node.body) || checkForAwait(node.body) || bodyReturnsThenable(node.body, typeChecker)) return;
+			context.report({
+				message: "missingAwait",
+				range: getTSNodeRange(asyncModifier, sourceFile)
+			});
+		}
+		return { visitors: {
+			ArrowFunction: checkFunction,
+			FunctionDeclaration: checkFunction,
+			FunctionExpression: checkFunction,
+			MethodDeclaration: checkFunction
+		} };
+	}
+});
+function bodyReturnsThenable(body, typeChecker) {
+	if (!ts$1.isBlock(body)) return tsutils.isThenableType(typeChecker, body);
+	function checkReturnStatements(node) {
+		if (ts$1.isReturnStatement(node) && node.expression && tsutils.isThenableType(typeChecker, node.expression)) return true;
+		if (tsutils.isFunctionScopeBoundary(node)) return false;
+		return ts$1.forEachChild(node, checkReturnStatements);
+	}
+	return ts$1.forEachChild(body, checkReturnStatements);
+}
+function checkForAwait(node) {
+	if (ts$1.isAwaitExpression(node)) return true;
+	if (ts$1.isForOfStatement(node) && node.awaitModifier) return true;
+	if (tsutils.isFunctionScopeBoundary(node)) return false;
+	return ts$1.forEachChild(node, checkForAwait);
+}
+function isEmptyBody(body) {
+	return ts$1.isBlock(body) && !body.statements.length;
+}
+//#endregion
+export { asyncFunctionAwaits_default as default };

package/lib/rules/asyncPromiseExecutors.d.ts

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

package/lib/rules/asyncPromiseExecutors.js

@@ -19,8 +19,8 @@ var asyncPromiseExecutors_default = ruleCreator.createRule(typescriptLanguage, {
 		suggestions: ["Remove the `async` keyword from the executor function.", "If you need to use `await` inside the Promise, consider restructuring your code to avoid the Promise constructor."]
 	} },
 	setup(context) {
-		return { visitors: { NewExpression: (node, { sourceFile, typeChecker }) => {
-			if (!isGlobalDeclaration(node.expression, typeChecker) || !node.arguments?.length) return;
+		return { visitors: { NewExpression: (node, { program, sourceFile, typeChecker }) => {
+			if (!isGlobalDeclaration(node.expression, typeChecker, program) || !node.arguments?.length) return;
 			const executor = nullThrows(node.arguments[0], "Expected there to be a promise executor!");
 			if (executor.kind !== SyntaxKind.FunctionExpression && executor.kind !== SyntaxKind.ArrowFunction) return;
 			const asyncModifier = executor.modifiers?.find((mod) => mod.kind === SyntaxKind.AsyncKeyword);
@@ -37,5 +37,3 @@ var asyncPromiseExecutors_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { asyncPromiseExecutors_default as default };
-
-//# sourceMappingURL=asyncPromiseExecutors.js.map

package/lib/rules/asyncUnnecessaryPromiseWrappers.d.ts

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

package/lib/rules/asyncUnnecessaryPromiseWrappers.js

@@ -48,5 +48,3 @@ function isAsyncFunction(node) {
 }
 //#endregion
 export { asyncUnnecessaryPromiseWrappers_default as default };
-
-//# sourceMappingURL=asyncUnnecessaryPromiseWrappers.js.map

package/lib/rules/atAccesses.d.ts

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

package/lib/rules/atAccesses.js

@@ -48,5 +48,3 @@ function isLengthMinusAccess(node, sourceFile) {
 }
 //#endregion
 export { atAccesses_default as default };
-
-//# sourceMappingURL=atAccesses.js.map

package/lib/rules/builtinCoercions.d.ts

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

package/lib/rules/builtinCoercions.js

@@ -2,14 +2,14 @@ import { ruleCreator } from "./ruleCreator.js";
 import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
 import * as ts$1 from "typescript";
 //#region src/rules/builtinCoercions.ts
-const nativeCoercionFunctions = new Set([
+const nativeCoercionFunctions = /* @__PURE__ */ new Set([
 	"BigInt",
 	"Boolean",
 	"Number",
 	"String",
 	"Symbol"
 ]);
-const arrayMethodsWithBooleanCallback = new Set([
+const arrayMethodsWithBooleanCallback = /* @__PURE__ */ new Set([
 	"every",
 	"filter",
 	"find",
@@ -113,5 +113,3 @@ function isIdentityFunction(node, soleParameterText) {
 }
 //#endregion
 export { builtinCoercions_default as default };
-
-//# sourceMappingURL=builtinCoercions.js.map

package/lib/rules/builtinConstructorNews.d.ts

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

package/lib/rules/builtinConstructorNews.js

@@ -2,7 +2,7 @@ import { ruleCreator } from "./ruleCreator.js";
 import { isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
 import * as ts$1 from "typescript";
 //#region src/rules/builtinConstructorNews.ts
-const requiresNew = new Set([
+const requiresNew = /* @__PURE__ */ new Set([
 	"Array",
 	"ArrayBuffer",
 	"BigInt64Array",
@@ -33,7 +33,7 @@ const requiresNew = new Set([
 	"WeakRef",
 	"WeakSet"
 ]);
-const disallowsNew = new Set([
+const disallowsNew = /* @__PURE__ */ new Set([
 	"BigInt",
 	"Boolean",
 	"Number",
@@ -59,11 +59,11 @@ var builtinConstructorNews_default = ruleCreator.createRule(typescriptLanguage,
 		}
 	},
 	setup(context) {
-		function checkNode(node, namesToReport, message, { sourceFile, typeChecker }) {
+		function checkNode(node, namesToReport, message, { program, sourceFile, typeChecker }) {
 			if (!ts$1.isIdentifier(node.expression)) return;
 			const name = node.expression.text;
 			if (!namesToReport.has(name)) return;
-			if (!isGlobalDeclarationOfName(node.expression, name, typeChecker)) return;
+			if (!isGlobalDeclarationOfName(node.expression, name, typeChecker, program)) return;
 			context.report({
 				data: { name },
 				message,
@@ -85,5 +85,3 @@ var builtinConstructorNews_default = ruleCreator.createRule(typescriptLanguage,
 });
 //#endregion
 export { builtinConstructorNews_default as default };
-
-//# sourceMappingURL=builtinConstructorNews.js.map

package/lib/rules/caseDeclarations.d.ts

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

package/lib/rules/caseDeclarations.js

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

package/lib/rules/caseDuplicates.d.ts

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

package/lib/rules/caseDuplicates.js

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

package/lib/rules/caseFallthroughs.d.ts

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

package/lib/rules/caseFallthroughs.js

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

package/lib/rules/catchCallbackTypes.d.ts

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

package/lib/rules/catchCallbackTypes.js

@@ -1,7 +1,7 @@
 import { ruleCreator } from "./ruleCreator.js";
 import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
 import { declarationIncludesGlobal, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
+import { TypeFlags, isFunctionLike, isInterfaceDeclaration, isPropertyAccessExpression } from "typescript";
 import * as tsutils from "ts-api-utils";
 //#region src/rules/catchCallbackTypes.ts
 var catchCallbackTypes_default = ruleCreator.createRule(typescriptLanguage, {
@@ -20,26 +20,26 @@ var catchCallbackTypes_default = ruleCreator.createRule(typescriptLanguage, {
 		suggestions: ["Add an explicit `: unknown` type annotation to the callback parameter."]
 	} },
 	setup(context) {
-		function isGlobalPromiseType(type) {
+		function isGlobalPromiseType(type, program) {
 			const symbol = type.getSymbol();
 			if (symbol?.getName() !== "Promise") return false;
 			const declarations = symbol.getDeclarations();
 			if (!declarations) return false;
-			return declarations.some((declaration) => ts$1.isInterfaceDeclaration(declaration) && declaration.name.text === "Promise" && declarationIncludesGlobal(declaration));
+			return declarations.some((declaration) => isInterfaceDeclaration(declaration) && declaration.name.text === "Promise" && declarationIncludesGlobal(declaration, program));
 		}
-		function isCatchOrThenCallback(node, typeChecker) {
-			if (!ts$1.isPropertyAccessExpression(node.expression)) return;
+		function isCatchOrThenCallback(node, typeChecker, program) {
+			if (!isPropertyAccessExpression(node.expression)) return;
 			const methodName = node.expression.name.text;
 			if (methodName !== "catch" && methodName !== "then") return;
-			if (!isGlobalPromiseType(getConstrainedTypeAtLocation(node.expression.expression, typeChecker))) return;
+			if (!isGlobalPromiseType(getConstrainedTypeAtLocation(node.expression.expression, typeChecker), program)) return;
 			return methodName === "catch" ? "catch" : "then";
 		}
 		function checkCallbackParameter(callback, sourceFile, typeChecker) {
-			if (!ts$1.isFunctionLike(callback) || !callback.parameters.length) return;
+			if (!isFunctionLike(callback) || !callback.parameters.length) return;
 			const firstParameter = callback.parameters[0];
 			if (firstParameter.type) {
 				const paramType = typeChecker.getTypeFromTypeNode(firstParameter.type);
-				if (tsutils.isTypeFlagSet(paramType, ts$1.TypeFlags.Unknown) || !tsutils.isTypeFlagSet(paramType, ts$1.TypeFlags.Any)) return;
+				if (tsutils.isTypeFlagSet(paramType, TypeFlags.Unknown) || !tsutils.isTypeFlagSet(paramType, TypeFlags.Any)) return;
 			}
 			context.report({
 				message: "preferUnknown",
@@ -49,8 +49,8 @@ var catchCallbackTypes_default = ruleCreator.createRule(typescriptLanguage, {
 				}
 			});
 		}
-		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
-			switch (isCatchOrThenCallback(node, typeChecker)) {
+		return { visitors: { CallExpression: (node, { program, sourceFile, typeChecker }) => {
+			switch (isCatchOrThenCallback(node, typeChecker, program)) {
 				case "catch":
 					if (node.arguments.length >= 1) checkCallbackParameter(node.arguments[0], sourceFile, typeChecker);
 					break;
@@ -63,5 +63,3 @@ var catchCallbackTypes_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { catchCallbackTypes_default as default };
-
-//# sourceMappingURL=catchCallbackTypes.js.map

package/lib/rules/caughtVariableNames.d.ts

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

package/lib/rules/caughtVariableNames.js

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

package/lib/rules/chainedAssignments.d.ts

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

package/lib/rules/chainedAssignments.js

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

package/lib/rules/charAtComparisons.d.ts

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

package/lib/rules/charAtComparisons.js

@@ -1,16 +1,13 @@
 import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import { getStaticStringValue, typescriptLanguage } from "@flint.fyi/typescript-language";
 import * as ts$1 from "typescript";
 //#region src/rules/charAtComparisons.ts
-const comparisonOperators = new Set([
+const comparisonOperators = /* @__PURE__ */ new Set([
 	ts$1.SyntaxKind.EqualsEqualsEqualsToken,
 	ts$1.SyntaxKind.EqualsEqualsToken,
 	ts$1.SyntaxKind.ExclamationEqualsEqualsToken,
 	ts$1.SyntaxKind.ExclamationEqualsToken
 ]);
-function getStringLiteralLength(node) {
-	return ts$1.isStringLiteral(node) || ts$1.isNoSubstitutionTemplateLiteral(node) ? node.text.length : void 0;
-}
 function isStringCharAtCall(node, typeChecker) {
 	return ts$1.isCallExpression(node) && ts$1.isPropertyAccessExpression(node.expression) && node.expression.name.text === "charAt" && isStringType(typeChecker.getTypeAtLocation(node.expression.expression));
 }
@@ -35,12 +32,12 @@ var charAtComparisons_default = ruleCreator.createRule(typescriptLanguage, {
 			if (isStringCharAtCall(node.left, typeChecker)) literal = node.right;
 			else if (isStringCharAtCall(node.right, typeChecker)) literal = node.left;
 			else return;
-			const length = getStringLiteralLength(literal);
-			if (length === void 0 || length <= 1) return;
+			const value = getStaticStringValue(literal);
+			if (value === void 0 || value.length <= 1) return;
 			const isEquality = node.operatorToken.kind === ts$1.SyntaxKind.EqualsEqualsEqualsToken || node.operatorToken.kind === ts$1.SyntaxKind.EqualsEqualsToken;
 			context.report({
 				data: {
-					length,
+					length: value.length,
 					result: isEquality ? "false" : "true"
 				},
 				message: "invalidComparison",
@@ -54,5 +51,3 @@ var charAtComparisons_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { charAtComparisons_default as default };
-
-//# sourceMappingURL=charAtComparisons.js.map

package/lib/rules/classAssignments.d.ts

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

package/lib/rules/classAssignments.js

@@ -1,5 +1,5 @@
 import { ruleCreator } from "./ruleCreator.js";
-import { getModifyingReferences, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { getModifyingReferences, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
 //#region src/rules/classAssignments.ts
 var classAssignments_default = ruleCreator.createRule(typescriptLanguage, {
 	about: {
@@ -13,20 +13,15 @@ var classAssignments_default = ruleCreator.createRule(typescriptLanguage, {
 		suggestions: ["Use a different variable name if you need to store a modified reference to a class."]
 	} },
 	setup(context) {
-		return { visitors: { ClassDeclaration: (node, { sourceFile, typeChecker }) => {
+		return { visitors: { ClassDeclaration: (node, { sourceFile }) => {
 			if (!node.name) return;
-			const modifyingReferences = getModifyingReferences(node.name, sourceFile, typeChecker);
+			const modifyingReferences = getModifyingReferences(node.name, sourceFile);
 			for (const reference of modifyingReferences) context.report({
 				message: "noClassAssign",
-				range: {
-					begin: reference.getStart(sourceFile),
-					end: reference.getEnd()
-				}
+				range: getTSNodeRange(reference, sourceFile)
 			});
 		} } };
 	}
 });
 //#endregion
 export { classAssignments_default as default };
-
-//# sourceMappingURL=classAssignments.js.map

package/lib/rules/classFieldDeclarations.d.ts

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

package/lib/rules/classFieldDeclarations.js

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

package/lib/rules/classLiteralProperties.d.ts

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

package/lib/rules/classLiteralProperties.js

@@ -41,5 +41,3 @@ function isLiteralValue(node) {
 }
 //#endregion
 export { classLiteralProperties_default as default };
-
-//# sourceMappingURL=classLiteralProperties.js.map

package/lib/rules/classMemberDuplicates.d.ts

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

package/lib/rules/classMemberDuplicates.js

@@ -67,5 +67,3 @@ function getNameText(name) {
 }
 //#endregion
 export { classMemberDuplicates_default as default };
-
-//# sourceMappingURL=classMemberDuplicates.js.map

package/lib/rules/classMethodsThis.d.ts

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

package/lib/rules/classMethodsThis.js

@@ -1,7 +1,7 @@
 import { ruleCreator } from "./ruleCreator.js";
 import { typescriptLanguage } from "@flint.fyi/typescript-language";
 import ts from "typescript";
-import { z } from "zod/v4";
+import { z as z$1 } from "zod/v4";
 //#region src/rules/classMethodsThis.ts
 function classImplementsSomething(classNode) {
 	return classNode.heritageClauses?.some((clause) => clause.token === ts.SyntaxKind.ImplementsKeyword) ?? false;
@@ -65,8 +65,8 @@ var classMethodsThis_default = ruleCreator.createRule(typescriptLanguage, {
 		suggestions: ["Add the `static` keyword to make this a static method.", "Extract this to a standalone function if it doesn't need class context."]
 	} },
 	options: {
-		ignoreClassesThatImplementAnInterface: z.union([z.boolean(), z.literal("public-fields")]).default(false).describe("Whether to ignore classes that implement interfaces. Set to 'public-fields' to only ignore public members."),
-		ignoreOverrideMethods: z.boolean().default(false).describe("Whether to ignore members with the 'override' modifier.")
+		ignoreClassesThatImplementAnInterface: z$1.union([z$1.boolean(), z$1.literal("public-fields")]).default(false).describe("Whether to ignore classes that implement interfaces. Set to 'public-fields' to only ignore public members."),
+		ignoreOverrideMethods: z$1.boolean().default(false).describe("Whether to ignore members with the 'override' modifier.")
 	},
 	setup(context) {
 		function reportMember(member, kind, sourceFile, reportFromStart) {
@@ -120,5 +120,3 @@ var classMethodsThis_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { classMethodsThis_default as default };
-
-//# sourceMappingURL=classMethodsThis.js.map

package/lib/rules/combinedPushes.d.ts

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

package/lib/rules/combinedPushes.js

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

package/lib/rules/consecutiveNonNullAssertions.d.ts

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

package/lib/rules/consecutiveNonNullAssertions.js

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

package/lib/rules/consoleCalls.d.ts

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