@flint.fyi/ts 0.19.1 → 0.21.0

package/lib/rules/restrictedIdentifiers.js

@@ -1,7 +1,7 @@
 import { ruleCreator } from "./ruleCreator.js";
 import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
 import ts from "typescript";
-import z$1 from "zod/v4";
+import z from "zod/v4";
 //#region src/rules/restrictedIdentifiers.ts
 var restrictedIdentifiers_default = ruleCreator.createRule(typescriptLanguage, {
 	about: {
@@ -14,7 +14,7 @@ var restrictedIdentifiers_default = ruleCreator.createRule(typescriptLanguage, {
 		secondary: ["This identifier name is on this project's denylist."],
 		suggestions: ["Rename the identifier to something allowed in the project."]
 	} },
-	options: { deny: z$1.array(z$1.string()).optional() },
+	options: { deny: z.array(z.string()).optional() },
 	setup(context) {
 		function checkNode(node, { options, sourceFile }) {
 			if (node.name?.kind !== ts.SyntaxKind.Identifier || !options.deny?.includes(node.name.text)) return;
@@ -37,5 +37,3 @@ var restrictedIdentifiers_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { restrictedIdentifiers_default as default };
-
-//# sourceMappingURL=restrictedIdentifiers.js.map

package/lib/rules/restrictedImports.d.ts

@@ -0,0 +1,26 @@
+import { z } from "zod/v4";
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Restricts specified modules from being imported.";
+    readonly id: "restrictedImports";
+} & {
+    readonly pluginId: string;
+    readonly url: string;
+}, "restricted" | "moduleRestricted" | "moduleRestrictedWithMessage" | "namespaceRestricted" | "namespaceRestrictedWithMessage" | "restrictedWithMessage", {
+    restrictions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        allowTypeImports: z.ZodOptional<z.ZodBoolean>;
+        message: z.ZodOptional<z.ZodString>;
+        specifier: z.ZodUnion<readonly [z.ZodObject<{
+            from: z.ZodLiteral<"file">;
+            name: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            from: z.ZodLiteral<"lib">;
+            name: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>, z.ZodObject<{
+            from: z.ZodLiteral<"package">;
+            name: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+            package: z.ZodString;
+        }, z.core.$strip>]>;
+    }, z.core.$strip>>>;
+}>;
+export default _default;

package/lib/rules/restrictedImports.js

@@ -0,0 +1,164 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getSpecifierNames } from "../type-utils/getSpecifierNames.js";
+import { matchesSpecifier } from "../type-utils/matchesSpecifier.js";
+import { typeOrValueSpecifierSchema } from "../type-utils/schemas.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts, { SyntaxKind } from "typescript";
+import { z as z$1 } from "zod/v4";
+//#region src/rules/restrictedImports.ts
+const restrictionSchema = z$1.object({
+	allowTypeImports: z$1.boolean().optional().describe("Whether type-only imports are exempt from the restriction."),
+	message: z$1.string().optional().describe("A custom message to display when the restriction is triggered."),
+	specifier: typeOrValueSpecifierSchema.describe("A TypeOrValueSpecifier identifying the restricted import.")
+});
+function resolveModuleDeclarations(moduleSpecifier, typeChecker) {
+	return typeChecker.getSymbolAtLocation(moduleSpecifier)?.getDeclarations();
+}
+function resolveSymbolDeclarations(nameNode, typeChecker) {
+	let symbol = typeChecker.getSymbolAtLocation(nameNode);
+	if (!symbol) return;
+	if (symbol.flags & ts.SymbolFlags.Alias) symbol = typeChecker.getAliasedSymbol(symbol);
+	return symbol.getDeclarations();
+}
+var restrictedImports_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Restricts specified modules from being imported.",
+		id: "restrictedImports"
+	},
+	messages: {
+		moduleRestricted: {
+			primary: "'{{ source }}' import is restricted.",
+			secondary: ["This module has been restricted by project configuration."],
+			suggestions: ["Remove this import or replace it with an allowed alternative."]
+		},
+		moduleRestrictedWithMessage: {
+			primary: "'{{ source }}' import is restricted. {{ customMessage }}",
+			secondary: ["This module has been restricted by project configuration."],
+			suggestions: ["Remove this import or replace it with an allowed alternative."]
+		},
+		namespaceRestricted: {
+			primary: "* import is invalid because '{{ restrictedNames }}' from '{{ source }}' is restricted.",
+			secondary: ["This import uses a namespace or wildcard import, but specific names from this module are restricted."],
+			suggestions: ["Replace the namespace import with named imports that are allowed."]
+		},
+		namespaceRestrictedWithMessage: {
+			primary: "* import is invalid because '{{ restrictedNames }}' from '{{ source }}' is restricted. {{ customMessage }}",
+			secondary: ["This import uses a namespace or wildcard import, but specific names from this module are restricted."],
+			suggestions: ["Replace the namespace import with named imports that are allowed."]
+		},
+		restricted: {
+			primary: "'{{ importName }}' import from '{{ source }}' is restricted.",
+			secondary: ["This import name has been restricted by project configuration."],
+			suggestions: ["Remove this import or replace it with an allowed alternative."]
+		},
+		restrictedWithMessage: {
+			primary: "'{{ importName }}' import from '{{ source }}' is restricted. {{ customMessage }}",
+			secondary: ["This import name has been restricted by project configuration."],
+			suggestions: ["Remove this import or replace it with an allowed alternative."]
+		}
+	},
+	options: { restrictions: z$1.array(restrictionSchema).default([]).describe("Restrictions on imports, using TypeOrValueSpecifier to identify targets.") },
+	setup(context) {
+		function checkNamedRestrictions(restrictions, declarations, importedName, isTypeOnly, source, range, program) {
+			for (const restriction of restrictions) {
+				if (restriction.allowTypeImports && isTypeOnly) continue;
+				if (matchesSpecifier(importedName, declarations, restriction.specifier, program)) context.report({
+					data: {
+						customMessage: restriction.message ?? "",
+						importName: importedName,
+						source
+					},
+					message: restriction.message ? "restrictedWithMessage" : "restricted",
+					range
+				});
+			}
+		}
+		function checkWildcardRestrictions(restrictions, moduleDeclarations, source, topLevelTypeOnly, range, program) {
+			for (const restriction of restrictions) {
+				if (restriction.allowTypeImports && topLevelTypeOnly) continue;
+				const names = getSpecifierNames(restriction.specifier);
+				if (names !== void 0) {
+					if (matchesSpecifier(void 0, moduleDeclarations, {
+						...restriction.specifier,
+						name: void 0
+					}, program)) context.report({
+						data: {
+							customMessage: restriction.message ?? "",
+							restrictedNames: names.join("', '"),
+							source
+						},
+						message: restriction.message ? "namespaceRestrictedWithMessage" : "namespaceRestricted",
+						range
+					});
+				} else if (matchesSpecifier(void 0, moduleDeclarations, restriction.specifier, program)) context.report({
+					data: {
+						customMessage: restriction.message ?? "",
+						source
+					},
+					message: restriction.message ? "moduleRestrictedWithMessage" : "moduleRestricted",
+					range
+				});
+			}
+		}
+		return { visitors: {
+			ExportDeclaration: (node, { options, program, sourceFile, typeChecker }) => {
+				if (!node.moduleSpecifier || !ts.isStringLiteral(node.moduleSpecifier)) return;
+				const source = node.moduleSpecifier.text;
+				const topLevelTypeOnly = node.isTypeOnly;
+				const range = getTSNodeRange(node, sourceFile);
+				if (node.exportClause && ts.isNamedExports(node.exportClause)) for (const element of node.exportClause.elements) {
+					const isTypeOnly = topLevelTypeOnly || element.isTypeOnly;
+					const importedName = element.propertyName ? element.propertyName.text : element.name.text;
+					const declarations = resolveSymbolDeclarations(element.name, typeChecker);
+					if (!declarations?.length) continue;
+					checkNamedRestrictions(options.restrictions, declarations, importedName, isTypeOnly, source, range, program);
+				}
+				else {
+					const moduleDeclarations = resolveModuleDeclarations(node.moduleSpecifier, typeChecker);
+					if (!moduleDeclarations?.length) return;
+					checkWildcardRestrictions(options.restrictions, moduleDeclarations, source, topLevelTypeOnly, range, program);
+				}
+			},
+			ImportDeclaration: (node, { options, program, sourceFile, typeChecker }) => {
+				if (!ts.isStringLiteral(node.moduleSpecifier)) return;
+				const source = node.moduleSpecifier.text;
+				const range = getTSNodeRange(node, sourceFile);
+				if (!node.importClause) {
+					const moduleDeclarations = resolveModuleDeclarations(node.moduleSpecifier, typeChecker);
+					if (!moduleDeclarations?.length) return;
+					for (const restriction of options.restrictions) if (matchesSpecifier(void 0, moduleDeclarations, restriction.specifier, program)) context.report({
+						data: {
+							customMessage: restriction.message ?? "",
+							source
+						},
+						message: restriction.message ? "moduleRestrictedWithMessage" : "moduleRestricted",
+						range
+					});
+					return;
+				}
+				const topLevelTypeOnly = node.importClause.phaseModifier === SyntaxKind.TypeKeyword;
+				if (node.importClause.name) {
+					const declarations = resolveSymbolDeclarations(node.importClause.name, typeChecker);
+					if (declarations?.length) checkNamedRestrictions(options.restrictions, declarations, "default", topLevelTypeOnly, source, range, program);
+				}
+				const bindings = node.importClause.namedBindings;
+				if (!bindings) return;
+				if (ts.isNamedImports(bindings)) {
+					for (const element of bindings.elements) {
+						const isTypeOnly = topLevelTypeOnly || element.isTypeOnly;
+						const importedName = element.propertyName ? element.propertyName.text : element.name.text;
+						const declarations = resolveSymbolDeclarations(element.name, typeChecker);
+						if (!declarations?.length) continue;
+						checkNamedRestrictions(options.restrictions, declarations, importedName, isTypeOnly, source, range, program);
+					}
+					return;
+				}
+				const moduleDeclarations = resolveModuleDeclarations(node.moduleSpecifier, typeChecker);
+				if (!moduleDeclarations?.length) return;
+				checkWildcardRestrictions(options.restrictions, moduleDeclarations, source, topLevelTypeOnly, range, program);
+			}
+		} };
+	}
+});
+//#endregion
+export { restrictedImports_default as default };

package/lib/rules/returnAssignments.d.ts

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

package/lib/rules/returnAssignments.js

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

package/lib/rules/returnThisTypes.d.ts

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

package/lib/rules/returnThisTypes.js

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

package/lib/rules/ruleCreator.d.ts

@@ -1,3 +1,2 @@
 import { RuleCreator } from "@flint.fyi/core";
 export declare const ruleCreator: RuleCreator<"javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict", import("@flint.fyi/core").RuleAbout<"javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict">>;
-//# sourceMappingURL=ruleCreator.d.ts.map

package/lib/rules/ruleCreator.js

@@ -13,5 +13,3 @@ const ruleCreator = new RuleCreator({
 });
 //#endregion
 export { ruleCreator };
-
-//# sourceMappingURL=ruleCreator.js.map

package/lib/rules/selfAssignments.d.ts

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

package/lib/rules/selfAssignments.js

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

package/lib/rules/sequences.d.ts

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

package/lib/rules/sequences.js

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

package/lib/rules/setSizeLengthChecks.d.ts

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

package/lib/rules/setSizeLengthChecks.js

@@ -1,22 +1,22 @@
 import { ruleCreator } from "./ruleCreator.js";
 import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
+import { NodeFlags, SyntaxKind, isArrayLiteralExpression, isIdentifier, isNewExpression, isParenthesizedExpression, isSpreadElement, isVariableDeclaration } from "typescript";
 //#region src/rules/setSizeLengthChecks.ts
-function isNewSetExpression(expression, typeChecker) {
-	return ts$1.isNewExpression(expression) && ts$1.isIdentifier(expression.expression) && expression.expression.text === "Set" && isGlobalDeclarationOfName(expression.expression, "Set", typeChecker);
+function isNewSetExpression(expression, typeChecker, program) {
+	return isNewExpression(expression) && isIdentifier(expression.expression) && expression.expression.text === "Set" && isGlobalDeclarationOfName(expression.expression, "Set", typeChecker, program);
 }
-function isSetExpression(expression, typeChecker) {
+function isSetExpression(expression, typeChecker, program) {
 	const unwrapped = unwrapParentheses(expression);
-	if (isNewSetExpression(unwrapped, typeChecker)) return true;
-	if (!ts$1.isIdentifier(unwrapped)) return false;
+	if (isNewSetExpression(unwrapped, typeChecker, program)) return true;
+	if (!isIdentifier(unwrapped)) return false;
 	const symbol = typeChecker.getSymbolAtLocation(unwrapped);
-	if (!symbol?.valueDeclaration || !ts$1.isVariableDeclaration(symbol.valueDeclaration)) return false;
+	if (!symbol?.valueDeclaration || !isVariableDeclaration(symbol.valueDeclaration)) return false;
 	const declaration = symbol.valueDeclaration;
-	if (declaration.parent.kind !== ts$1.SyntaxKind.VariableDeclarationList || !(declaration.parent.flags & ts$1.NodeFlags.Const) || !declaration.initializer) return false;
-	return isNewSetExpression(unwrapParentheses(declaration.initializer), typeChecker);
+	if (declaration.parent.kind !== SyntaxKind.VariableDeclarationList || !(declaration.parent.flags & NodeFlags.Const) || !declaration.initializer) return false;
+	return isNewSetExpression(unwrapParentheses(declaration.initializer), typeChecker, program);
 }
 function unwrapParentheses(expression) {
-	while (ts$1.isParenthesizedExpression(expression)) expression = expression.expression;
+	while (isParenthesizedExpression(expression)) expression = expression.expression;
 	return expression;
 }
 var setSizeLengthChecks_default = ruleCreator.createRule(typescriptLanguage, {
@@ -31,10 +31,10 @@ var setSizeLengthChecks_default = ruleCreator.createRule(typescriptLanguage, {
 		suggestions: ["Use `.size` directly on the `Set` instead."]
 	} },
 	setup(context) {
-		return { visitors: { PropertyAccessExpression: (node, { sourceFile, typeChecker }) => {
-			if (node.questionDotToken || node.name.text !== "length" || !ts$1.isArrayLiteralExpression(node.expression) || node.expression.elements.length !== 1) return;
+		return { visitors: { PropertyAccessExpression: (node, { program, sourceFile, typeChecker }) => {
+			if (node.questionDotToken || node.name.text !== "length" || !isArrayLiteralExpression(node.expression) || node.expression.elements.length !== 1) return;
 			const element = node.expression.elements[0];
-			if (!ts$1.isSpreadElement(element) || !isSetExpression(element.expression, typeChecker)) return;
+			if (!isSpreadElement(element) || !isSetExpression(element.expression, typeChecker, program)) return;
 			context.report({
 				message: "preferSize",
 				range: getTSNodeRange(node, sourceFile)
@@ -44,5 +44,3 @@ var setSizeLengthChecks_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { setSizeLengthChecks_default as default };
-
-//# sourceMappingURL=setSizeLengthChecks.js.map

package/lib/rules/setterReturns.d.ts

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

package/lib/rules/setterReturns.js

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

package/lib/rules/shadowedRestrictedNames.d.ts

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

package/lib/rules/shadowedRestrictedNames.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/shadowedRestrictedNames.ts
-const restrictedNames = new Set([
+const restrictedNames = /* @__PURE__ */ new Set([
 	"arguments",
 	"eval",
 	"Infinity",
@@ -64,5 +64,3 @@ var shadowedRestrictedNames_default = ruleCreator.createRule(typescriptLanguage,
 });
 //#endregion
 export { shadowedRestrictedNames_default as default };
-
-//# sourceMappingURL=shadowedRestrictedNames.js.map

package/lib/rules/singleVariableDeclarations.d.ts

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

package/lib/rules/singleVariableDeclarations.js

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

package/lib/rules/sizeComparisonOperators.d.ts

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

package/lib/rules/sizeComparisonOperators.js

@@ -1,9 +1,9 @@
 import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { getStaticNumberValue, getTSNodeRange, 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/sizeComparisonOperators.ts
-const sizePropertyNames = new Set(["length", "size"]);
+const sizePropertyNames = /* @__PURE__ */ new Set(["length", "size"]);
 function hasLogicalOrFallback(node) {
 	return ts$1.isBinaryExpression(node.parent) && node.parent.operatorToken.kind === ts$1.SyntaxKind.BarBarToken && node.parent.left === node;
 }
@@ -83,13 +83,13 @@ var sizeComparisonOperators_default = ruleCreator.createRule(typescriptLanguage,
 			suggestions: ["Replace with `.{{ property }} === 0`."]
 		}
 	},
-	options: { style: z.enum(["coercion", "explicit"]).default("coercion").describe("Which style to enforce: 'coercion' for implicit boolean checks like `if (arr.length)`, or 'explicit' for comparisons like `if (arr.length > 0)`.") },
+	options: { style: z$1.enum(["coercion", "explicit"]).default("coercion").describe("Which style to enforce: 'coercion' for implicit boolean checks like `if (arr.length)`, or 'explicit' for comparisons like `if (arr.length > 0)`.") },
 	setup(context) {
 		return { visitors: {
 			BinaryExpression: (node, { options, sourceFile }) => {
 				if (options.style !== "coercion") return;
 				const { left, operatorToken, right } = node;
-				if (!ts$1.isPropertyAccessExpression(left) || !sizePropertyNames.has(left.name.text) || !ts$1.isNumericLiteral(right) || right.text !== "0") return;
+				if (!ts$1.isPropertyAccessExpression(left) || !sizePropertyNames.has(left.name.text) || !Object.is(getStaticNumberValue(right), 0)) return;
 				const isNonZeroCheck = operatorToken.kind === ts$1.SyntaxKind.GreaterThanToken || operatorToken.kind === ts$1.SyntaxKind.ExclamationEqualsEqualsToken || operatorToken.kind === ts$1.SyntaxKind.ExclamationEqualsToken;
 				const isZeroCheck = operatorToken.kind === ts$1.SyntaxKind.EqualsEqualsEqualsToken || operatorToken.kind === ts$1.SyntaxKind.EqualsEqualsToken || operatorToken.kind === ts$1.SyntaxKind.LessThanEqualsToken;
 				if (!isNonZeroCheck && !isZeroCheck) return;
@@ -144,5 +144,3 @@ var sizeComparisonOperators_default = ruleCreator.createRule(typescriptLanguage,
 });
 //#endregion
 export { sizeComparisonOperators_default as default };
-
-//# sourceMappingURL=sizeComparisonOperators.js.map

package/lib/rules/sparseArrays.d.ts

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

package/lib/rules/sparseArrays.js

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

package/lib/rules/staticMemberOnlyClasses.d.ts

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

package/lib/rules/staticMemberOnlyClasses.js

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

package/lib/rules/stringCaseMismatches.d.ts

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

package/lib/rules/stringCaseMismatches.js

@@ -1,13 +1,10 @@
 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/stringCaseMismatches.ts
 function isLowerCase(text) {
 	return text === text.toLowerCase();
 }
-function isStringLiteral$1(node) {
-	return ts$1.isStringLiteral(node) || ts$1.isNoSubstitutionTemplateLiteral(node);
-}
 function isUpperCase(text) {
 	return text === text.toUpperCase();
 }
@@ -29,8 +26,8 @@ var stringCaseMismatches_default = ruleCreator.createRule(typescriptLanguage, {
 			const operator = node.parent.operatorToken.kind;
 			if (operator !== ts$1.SyntaxKind.EqualsEqualsToken && operator !== ts$1.SyntaxKind.EqualsEqualsEqualsToken && operator !== ts$1.SyntaxKind.ExclamationEqualsToken && operator !== ts$1.SyntaxKind.ExclamationEqualsEqualsToken) return;
 			const otherSide = node.parent.left === node ? node.parent.right : node.parent.left;
-			if (!isStringLiteral$1(otherSide)) return;
-			const value = otherSide.text;
+			const value = getStaticStringValue(otherSide);
+			if (value === void 0) return;
 			const isToLower = node.expression.name.text === "toLowerCase";
 			const expectedCase = isToLower ? "lowercase" : "uppercase";
 			if (isToLower ? isLowerCase(value) : isUpperCase(value)) return;
@@ -54,5 +51,3 @@ var stringCaseMismatches_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { stringCaseMismatches_default as default };
-
-//# sourceMappingURL=stringCaseMismatches.js.map

package/lib/rules/stringCodePoints.d.ts

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

package/lib/rules/stringCodePoints.js

@@ -32,8 +32,8 @@ var stringCodePoints_default = ruleCreator.createRule(typescriptLanguage, {
 					}
 				});
 			},
-			PropertyAccessExpression(node, { sourceFile, typeChecker }) {
-				if (node.name.text === "fromCharCode" && ts$1.isIdentifier(node.expression) && isGlobalDeclarationOfName(node.expression, "String", typeChecker)) context.report({
+			PropertyAccessExpression(node, { program, sourceFile, typeChecker }) {
+				if (node.name.text === "fromCharCode" && ts$1.isIdentifier(node.expression) && isGlobalDeclarationOfName(node.expression, "String", typeChecker, program)) context.report({
 					message: "preferFromCodePoint",
 					range: {
 						begin: node.name.getStart(sourceFile),
@@ -46,5 +46,3 @@ var stringCodePoints_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { stringCodePoints_default as default };
-
-//# sourceMappingURL=stringCodePoints.js.map

package/lib/rules/stringSliceMethods.d.ts

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

package/lib/rules/stringSliceMethods.js

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

package/lib/rules/stringStartsEndsWith.d.ts

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

package/lib/rules/stringStartsEndsWith.js

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

package/lib/rules/structuredCloneMethods.d.ts

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

package/lib/rules/structuredCloneMethods.js

@@ -1,9 +1,9 @@
 import { ruleCreator } from "./ruleCreator.js";
 import { isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
+import { isCallExpression, isIdentifier, isPropertyAccessExpression, isSpreadElement } from "typescript";
 //#region src/rules/structuredCloneMethods.ts
-function isJsonMethod(node, methodName, typeChecker) {
-	return ts$1.isCallExpression(node) && ts$1.isPropertyAccessExpression(node.expression) && ts$1.isIdentifier(node.expression.expression) && isGlobalDeclarationOfName(node.expression.expression, "JSON", typeChecker) && node.expression.expression.text === "JSON" && node.expression.name.text === methodName;
+function isJsonMethod(node, methodName, typeChecker, program) {
+	return isCallExpression(node) && isPropertyAccessExpression(node.expression) && isIdentifier(node.expression.expression) && isGlobalDeclarationOfName(node.expression.expression, "JSON", typeChecker, program) && node.expression.expression.text === "JSON" && node.expression.name.text === methodName;
 }
 var structuredCloneMethods_default = ruleCreator.createRule(typescriptLanguage, {
 	about: {
@@ -17,12 +17,12 @@ var structuredCloneMethods_default = ruleCreator.createRule(typescriptLanguage,
 		suggestions: ["Replace with structuredClone()."]
 	} },
 	setup(context) {
-		return { visitors: { CallExpression(node, { sourceFile, typeChecker }) {
-			if (!isJsonMethod(node, "parse", typeChecker) || node.arguments.length !== 1) return;
+		return { visitors: { CallExpression(node, { program, sourceFile, typeChecker }) {
+			if (!isJsonMethod(node, "parse", typeChecker, program) || node.arguments.length !== 1) return;
 			const argument = node.arguments[0];
-			if (ts$1.isSpreadElement(argument) || !isJsonMethod(argument, "stringify", typeChecker) || argument.arguments.length !== 1) return;
+			if (isSpreadElement(argument) || !isJsonMethod(argument, "stringify", typeChecker, program) || argument.arguments.length !== 1) return;
 			const stringifyArgument = argument.arguments[0];
-			if (ts$1.isSpreadElement(stringifyArgument)) return;
+			if (isSpreadElement(stringifyArgument)) return;
 			context.report({
 				message: "preferStructuredClone",
 				range: {
@@ -35,5 +35,3 @@ var structuredCloneMethods_default = ruleCreator.createRule(typescriptLanguage,
 });
 //#endregion
 export { structuredCloneMethods_default as default };
-
-//# sourceMappingURL=structuredCloneMethods.js.map

package/lib/rules/symbolDescriptions.d.ts

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

package/lib/rules/symbolDescriptions.js

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

package/lib/rules/thisAliases.d.ts

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

package/lib/rules/thisAliases.js

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

package/lib/rules/thisBeforeSuper.d.ts

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

package/lib/rules/thisBeforeSuper.js

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