@flint.fyi/ts 0.19.1 → 0.21.0

package/lib/rules/numericLiteralParsing.js

@@ -1,5 +1,5 @@
 import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, isGlobalDeclaration, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { getStaticNumberValue, getStaticStringValue, getTSNodeRange, isGlobalDeclaration, typescriptLanguage } from "@flint.fyi/typescript-language";
 import { SyntaxKind } from "typescript";
 import { nullThrows } from "@flint.fyi/utils";
 //#region src/rules/numericLiteralParsing.ts
@@ -13,19 +13,6 @@ function convertToLiteral(value, radix) {
 		default: return value;
 	}
 }
-function getRadixValue(node) {
-	if (node.kind !== SyntaxKind.NumericLiteral) return;
-	const value = Number(node.text);
-	if (![
-		2,
-		8,
-		16
-	].includes(value)) return;
-	return value;
-}
-function getStringValue(node) {
-	return node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral ? node.text : void 0;
-}
 var numericLiteralParsing_default = ruleCreator.createRule(typescriptLanguage, {
 	about: {
 		description: "Reports parseInt calls with binary, hexadecimal, or octal strings that can be replaced with numeric literals.",
@@ -40,10 +27,14 @@ var numericLiteralParsing_default = ruleCreator.createRule(typescriptLanguage, {
 	setup(context) {
 		function checkParseIntCall(node, sourceFile) {
 			if (node.arguments.length !== 2) return;
-			const stringValue = getStringValue(nullThrows(node.arguments[0], "First argument is expected to be present by prior length check"));
+			const stringValue = getStaticStringValue(nullThrows(node.arguments[0], "First argument is expected to be present by prior length check"));
 			if (!stringValue) return;
-			const radixValue = getRadixValue(nullThrows(node.arguments[1], "Second argument is expected to be present by prior length check"));
-			if (!radixValue) return;
+			const radixValue = getStaticNumberValue(nullThrows(node.arguments[1], "Second argument is expected to be present by prior length check"));
+			if (radixValue === void 0 || ![
+				2,
+				8,
+				16
+			].includes(radixValue)) return;
 			context.report({
 				data: {
 					literal: convertToLiteral(stringValue, radixValue),
@@ -53,14 +44,12 @@ var numericLiteralParsing_default = ruleCreator.createRule(typescriptLanguage, {
 				range: getTSNodeRange(node, sourceFile)
 			});
 		}
-		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
+		return { visitors: { CallExpression: (node, { program, sourceFile, typeChecker }) => {
 			if (node.expression.kind === SyntaxKind.Identifier) {
-				if (node.expression.text === "parseInt" && isGlobalDeclaration(node.expression, typeChecker)) checkParseIntCall(node, sourceFile);
-			} else if (node.expression.kind === SyntaxKind.PropertyAccessExpression && node.expression.expression.kind === SyntaxKind.Identifier && node.expression.expression.text === "Number" && node.expression.name.kind === SyntaxKind.Identifier && node.expression.name.text === "parseInt" && isGlobalDeclaration(node.expression.expression, typeChecker)) checkParseIntCall(node, sourceFile);
+				if (node.expression.text === "parseInt" && isGlobalDeclaration(node.expression, typeChecker, program)) checkParseIntCall(node, sourceFile);
+			} else if (node.expression.kind === SyntaxKind.PropertyAccessExpression && node.expression.expression.kind === SyntaxKind.Identifier && node.expression.expression.text === "Number" && node.expression.name.kind === SyntaxKind.Identifier && node.expression.name.text === "parseInt" && isGlobalDeclaration(node.expression.expression, typeChecker, program)) checkParseIntCall(node, sourceFile);
 		} } };
 	}
 });
 //#endregion
 export { numericLiteralParsing_default as default };
-
-//# sourceMappingURL=numericLiteralParsing.js.map

package/lib/rules/numericPrecision.d.ts

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

package/lib/rules/numericPrecision.js

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

package/lib/rules/numericSeparatorGroups.d.ts

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

package/lib/rules/numericSeparatorGroups.js

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

package/lib/rules/objectAssignSpreads.d.ts

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

package/lib/rules/objectAssignSpreads.js

@@ -11,8 +11,8 @@ function hasArgumentsWithAccessors(node) {
 function hasArraySpread(node) {
 	return node.arguments.some((argument) => argument.kind === SyntaxKind.SpreadElement);
 }
-function isObjectAssignCall(node, typeChecker) {
-	return node.expression.kind === SyntaxKind.PropertyAccessExpression && node.expression.name.kind === SyntaxKind.Identifier && node.expression.name.text === "assign" && node.expression.expression.kind === SyntaxKind.Identifier && isGlobalDeclarationOfName(node.expression.expression, "Object", typeChecker);
+function isObjectAssignCall(node, typeChecker, program) {
+	return node.expression.kind === SyntaxKind.PropertyAccessExpression && node.expression.name.kind === SyntaxKind.Identifier && node.expression.name.text === "assign" && node.expression.expression.kind === SyntaxKind.Identifier && isGlobalDeclarationOfName(node.expression.expression, "Object", typeChecker, program);
 }
 var objectAssignSpreads_default = ruleCreator.createRule(typescriptLanguage, {
 	about: {
@@ -37,8 +37,8 @@ var objectAssignSpreads_default = ruleCreator.createRule(typescriptLanguage, {
 		}
 	},
 	setup(context) {
-		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
-			if (!isObjectAssignCall(node, typeChecker) || node.arguments.length < 1) return;
+		return { visitors: { CallExpression: (node, { program, sourceFile, typeChecker }) => {
+			if (!isObjectAssignCall(node, typeChecker, program) || node.arguments.length < 1) return;
 			if (node.arguments[0].kind !== SyntaxKind.ObjectLiteralExpression || hasArraySpread(node) || hasArgumentsWithAccessors(node)) return;
 			context.report({
 				message: node.arguments.length === 1 ? "preferObjectLiteral" : "preferObjectSpread",
@@ -49,5 +49,3 @@ var objectAssignSpreads_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { objectAssignSpreads_default as default };
-
-//# sourceMappingURL=objectAssignSpreads.js.map

package/lib/rules/objectCalls.d.ts

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

package/lib/rules/objectCalls.js

@@ -18,8 +18,8 @@ var objectCalls_default = ruleCreator.createRule(typescriptLanguage, {
 		suggestions: ["Replace `Object()` or `new Object()` with `{}` to create an empty object.", "Use `Object.create(null)` when you need an object without a prototype."]
 	} },
 	setup(context) {
-		function checkNode(node, { sourceFile, typeChecker }) {
-			if (node.expression.kind !== SyntaxKind.Identifier || !isGlobalDeclarationOfName(node.expression, "Object", typeChecker)) return;
+		function checkNode(node, { program, sourceFile, typeChecker }) {
+			if (node.expression.kind !== SyntaxKind.Identifier || !isGlobalDeclarationOfName(node.expression, "Object", typeChecker, program)) return;
 			const reportNode = node.kind === SyntaxKind.NewExpression ? node.getChildAt(0, sourceFile) : node.expression;
 			context.report({
 				message: "preferObjectLiteral",
@@ -34,5 +34,3 @@ var objectCalls_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { objectCalls_default as default };
-
-//# sourceMappingURL=objectCalls.js.map

package/lib/rules/objectEntriesMethods.d.ts

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

package/lib/rules/objectEntriesMethods.js

@@ -7,20 +7,20 @@ import { SyntaxKind } from "typescript";
 function isArrowFunctionWithParams(node) {
 	return node.kind === SyntaxKind.ArrowFunction && !!node.parameters.length;
 }
-function isEmptyObject(node, typeChecker) {
+function isEmptyObject(node, typeChecker, program) {
 	const unwrapped = skipParentheses(node);
-	return isEmptyObjectLiteral(unwrapped) || isObjectCreateNull(unwrapped, typeChecker);
+	return isEmptyObjectLiteral(unwrapped) || isObjectCreateNull(unwrapped, typeChecker, program);
 }
 function isEmptyObjectLiteral(node) {
 	return node.kind === SyntaxKind.ObjectLiteralExpression && !node.properties.length;
 }
-function isObjectAssignPattern(callback, typeChecker) {
+function isObjectAssignPattern(callback, typeChecker, program) {
 	if (callback.parameters.length < 1) return false;
 	const firstParameter = callback.parameters[0];
 	if (firstParameter.name.kind !== SyntaxKind.Identifier) return false;
 	const accumulatorName = firstParameter.name.text;
 	const body = skipParentheses(callback.body);
-	if (!isObjectMethodCall(body, "assign", typeChecker) || body.arguments.length !== 2 || !isGlobalDeclarationOfName(body.expression.expression, "Object", typeChecker)) return false;
+	if (!isObjectMethodCall(body, "assign", typeChecker, program) || body.arguments.length !== 2 || !isGlobalDeclarationOfName(body.expression.expression, "Object", typeChecker, program)) return false;
 	const firstArg = body.arguments[0];
 	if (firstArg.kind !== SyntaxKind.Identifier || firstArg.text !== accumulatorName) return false;
 	const secondArg = body.arguments[1];
@@ -28,17 +28,17 @@ function isObjectAssignPattern(callback, typeChecker) {
 	const property = secondArg.properties[0];
 	return property.kind === SyntaxKind.PropertyAssignment && property.name.kind === SyntaxKind.ComputedPropertyName;
 }
-function isObjectCreateNull(node, typeChecker) {
-	if (!isObjectMethodCall(node, "create", typeChecker) || !isGlobalDeclarationOfName(node.expression.expression, "Object", typeChecker) || node.arguments.length !== 1) return false;
+function isObjectCreateNull(node, typeChecker, program) {
+	if (!isObjectMethodCall(node, "create", typeChecker, program) || !isGlobalDeclarationOfName(node.expression.expression, "Object", typeChecker, program) || node.arguments.length !== 1) return false;
 	return node.arguments[0].kind === SyntaxKind.NullKeyword;
 }
-function isObjectMethodCall(node, text, typeChecker) {
-	return node.kind === SyntaxKind.CallExpression && node.expression.kind === SyntaxKind.PropertyAccessExpression && node.expression.name.kind === SyntaxKind.Identifier && node.expression.name.text === text && isGlobalDeclarationOfName(node.expression.expression, "Object", typeChecker);
+function isObjectMethodCall(node, text, typeChecker, program) {
+	return node.kind === SyntaxKind.CallExpression && node.expression.kind === SyntaxKind.PropertyAccessExpression && node.expression.name.kind === SyntaxKind.Identifier && node.expression.name.text === text && isGlobalDeclarationOfName(node.expression.expression, "Object", typeChecker, program);
 }
-function isReduceCallWithEmptyObject(node, typeChecker) {
+function isReduceCallWithEmptyObject(node, typeChecker, program) {
 	if (node.expression.kind !== SyntaxKind.PropertyAccessExpression || node.expression.name.kind !== SyntaxKind.Identifier || node.expression.name.text !== "reduce" || node.questionDotToken !== void 0 || node.arguments.length !== 2) return false;
 	const initialValue = node.arguments[1];
-	return isEmptyObject(initialValue, typeChecker) && isArrayOrTupleTypeAtLocation(node.expression.expression, typeChecker);
+	return isEmptyObject(initialValue, typeChecker, program) && isArrayOrTupleTypeAtLocation(node.expression.expression, typeChecker);
 }
 function isSpreadAccumulatorPattern(callback) {
 	if (callback.parameters.length < 1) return false;
@@ -64,11 +64,11 @@ var objectEntriesMethods_default = ruleCreator.createRule(typescriptLanguage, {
 		suggestions: ["Convert the array to key-value pairs with map() and use Object.fromEntries()."]
 	} },
 	setup(context) {
-		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
-			if (!isReduceCallWithEmptyObject(node, typeChecker)) return;
+		return { visitors: { CallExpression: (node, { program, sourceFile, typeChecker }) => {
+			if (!isReduceCallWithEmptyObject(node, typeChecker, program)) return;
 			const callback = node.arguments[0];
 			if (!isArrowFunctionWithParams(callback) || callback.body.kind === SyntaxKind.Block) return;
-			if (!isObjectAssignPattern(callback, typeChecker) && !isSpreadAccumulatorPattern(callback)) return;
+			if (!isObjectAssignPattern(callback, typeChecker, program) && !isSpreadAccumulatorPattern(callback)) return;
 			context.report({
 				message: "preferFromEntries",
 				range: getTSNodeRange(node, sourceFile)
@@ -78,5 +78,3 @@ var objectEntriesMethods_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { objectEntriesMethods_default as default };
-
-//# sourceMappingURL=objectEntriesMethods.js.map

package/lib/rules/objectHasOwns.d.ts

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

package/lib/rules/objectHasOwns.js

@@ -18,26 +18,26 @@ var objectHasOwns_default = ruleCreator.createRule(typescriptLanguage, {
 		suggestions: ["Use the safer, more modern `Object.hasOwn(obj, key)`.", "Use an alternative key check such as the `in` operator."]
 	} },
 	setup(context) {
-		function isObjectPrototypeHasOwnProperty(node, typeChecker) {
-			return node.kind === SyntaxKind.PropertyAccessExpression && node.name.kind === SyntaxKind.Identifier && node.name.text === "prototype" && node.expression.kind === SyntaxKind.Identifier && isGlobalDeclarationOfName(node.expression, "Object", typeChecker);
+		function isObjectPrototypeHasOwnProperty(node, typeChecker, program) {
+			return node.kind === SyntaxKind.PropertyAccessExpression && node.name.kind === SyntaxKind.Identifier && node.name.text === "prototype" && node.expression.kind === SyntaxKind.Identifier && isGlobalDeclarationOfName(node.expression, "Object", typeChecker, program);
 		}
 		function isObjectLiteralHasOwnProperty(node) {
 			return node.kind === SyntaxKind.ObjectLiteralExpression && !node.properties.length;
 		}
-		function isHasOwnProperty(node, typeChecker) {
+		function isHasOwnProperty(node, typeChecker, program) {
 			if (node.kind !== SyntaxKind.PropertyAccessExpression || node.name.kind !== SyntaxKind.Identifier || node.name.text !== "hasOwnProperty") return false;
-			return isObjectPrototypeHasOwnProperty(node.expression, typeChecker) || isObjectLiteralHasOwnProperty(node.expression);
+			return isObjectPrototypeHasOwnProperty(node.expression, typeChecker, program) || isObjectLiteralHasOwnProperty(node.expression);
 		}
-		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
+		return { visitors: { CallExpression: (node, { program, sourceFile, typeChecker }) => {
 			if (node.expression.kind !== SyntaxKind.PropertyAccessExpression || node.expression.name.kind !== SyntaxKind.Identifier) return;
-			if (node.expression.name.text === "call" && node.arguments.length >= 2 && isHasOwnProperty(node.expression.expression, typeChecker)) {
+			if (node.expression.name.text === "call" && node.arguments.length >= 2 && isHasOwnProperty(node.expression.expression, typeChecker, program)) {
 				context.report({
 					message: "preferHasOwn",
 					range: getTSNodeRange(node, sourceFile)
 				});
 				return;
 			}
-			if (node.expression.name.text === "hasOwnProperty" && node.arguments.length >= 1 && !isHasOwnProperty(node.expression, typeChecker)) context.report({
+			if (node.expression.name.text === "hasOwnProperty" && node.arguments.length >= 1 && !isHasOwnProperty(node.expression, typeChecker, program)) context.report({
 				message: "preferHasOwn",
 				range: getTSNodeRange(node, sourceFile)
 			});
@@ -46,5 +46,3 @@ var objectHasOwns_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { objectHasOwns_default as default };
-
-//# sourceMappingURL=objectHasOwns.js.map

package/lib/rules/objectKeyDuplicates.d.ts

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

package/lib/rules/objectKeyDuplicates.js

@@ -59,5 +59,3 @@ function getPropertyKeyName(property) {
 }
 //#endregion
 export { objectKeyDuplicates_default as default };
-
-//# sourceMappingURL=objectKeyDuplicates.js.map

package/lib/rules/objectProto.d.ts

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

package/lib/rules/objectProto.js

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

package/lib/rules/objectPrototypeBuiltIns.d.ts

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

package/lib/rules/objectPrototypeBuiltIns.js

@@ -3,7 +3,7 @@ import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-langua
 import { SyntaxKind } from "typescript";
 import { nullThrows } from "@flint.fyi/utils";
 //#region src/rules/objectPrototypeBuiltIns.ts
-const prototypeMethods = new Set([
+const prototypeMethods = /* @__PURE__ */ new Set([
 	"hasOwnProperty",
 	"isPrototypeOf",
 	"propertyIsEnumerable"
@@ -50,5 +50,3 @@ function findToken(node, token, sourceFile) {
 }
 //#endregion
 export { objectPrototypeBuiltIns_default as default };
-
-//# sourceMappingURL=objectPrototypeBuiltIns.js.map

package/lib/rules/objectShorthand.d.ts

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

package/lib/rules/objectShorthand.js

@@ -80,5 +80,3 @@ function isValidIdentifier(name) {
 }
 //#endregion
 export { objectShorthand_default as default };
-
-//# sourceMappingURL=objectShorthand.js.map

package/lib/rules/objectSpreadUnnecessaryFallbacks.d.ts

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

package/lib/rules/objectSpreadUnnecessaryFallbacks.js

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

package/lib/rules/objectTypeDefinitions.d.ts

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

package/lib/rules/objectTypeDefinitions.js

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

package/lib/rules/octalEscapes.d.ts

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

package/lib/rules/octalEscapes.js

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

package/lib/rules/octalNumbers.d.ts

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

package/lib/rules/octalNumbers.js

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

package/lib/rules/operatorAssignmentShorthand.d.ts

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

package/lib/rules/operatorAssignmentShorthand.js

@@ -2,7 +2,7 @@ import { ruleCreator } from "./ruleCreator.js";
 import { getTSNodeRange, hasSameTokens, typescriptLanguage } from "@flint.fyi/typescript-language";
 import ts from "typescript";
 //#region src/rules/operatorAssignmentShorthand.ts
-const operatorTexts = new Map([
+const operatorTexts = /* @__PURE__ */ new Map([
 	[ts.SyntaxKind.AmpersandToken, "&"],
 	[ts.SyntaxKind.AsteriskAsteriskToken, "**"],
 	[ts.SyntaxKind.AsteriskToken, "*"],
@@ -16,13 +16,13 @@ const operatorTexts = new Map([
 	[ts.SyntaxKind.PlusToken, "+"],
 	[ts.SyntaxKind.SlashToken, "/"]
 ]);
-const commutativeOperatorsWithShorthand = new Set([
+const commutativeOperatorsWithShorthand = /* @__PURE__ */ new Set([
 	"&",
 	"*",
 	"^",
 	"|"
 ]);
-const nonCommutativeOperatorsWithShorthand = new Set([
+const nonCommutativeOperatorsWithShorthand = /* @__PURE__ */ new Set([
 	"%",
 	"**",
 	"+",
@@ -73,5 +73,3 @@ var operatorAssignmentShorthand_default = ruleCreator.createRule(typescriptLangu
 });
 //#endregion
 export { operatorAssignmentShorthand_default as default };
-
-//# sourceMappingURL=operatorAssignmentShorthand.js.map

package/lib/rules/overloadSignaturesAdjacent.d.ts

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

package/lib/rules/overloadSignaturesAdjacent.js

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

package/lib/rules/parameterReassignments.d.ts

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

package/lib/rules/parameterReassignments.js

@@ -1,20 +1,6 @@
 import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
+import { getScopeManager, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
 //#region src/rules/parameterReassignments.ts
-function collectParameterNames(parameters) {
-	const names = /* @__PURE__ */ new Set();
-	const collectNames = (node) => {
-		if (node.kind === ts.SyntaxKind.Identifier) names.add(node.text);
-		else if (ts.isObjectBindingPattern(node)) {
-			for (const element of node.elements) if (!ts.isOmittedExpression(element)) collectNames(element.name);
-		} else if (ts.isArrayBindingPattern(node)) {
-			for (const element of node.elements) if (!ts.isOmittedExpression(element)) collectNames(element.name);
-		}
-	};
-	for (const parameter of parameters) collectNames(parameter.name);
-	return names;
-}
 var parameterReassignments_default = ruleCreator.createRule(typescriptLanguage, {
 	about: {
 		description: "Disallow reassignment of function parameters.",
@@ -31,46 +17,27 @@ var parameterReassignments_default = ruleCreator.createRule(typescriptLanguage,
 		suggestions: ["Use a new variable if you need to modify the value.", "Use a different pattern such as a helper function."]
 	} },
 	setup(context) {
-		const scopes = /* @__PURE__ */ new Map();
-		const checkParameterAssignment = (name, node, sourceFile) => {
-			let currentNode = node;
-			while (currentNode !== void 0) {
-				if (ts.isFunctionDeclaration(currentNode) || ts.isFunctionExpression(currentNode) || ts.isArrowFunction(currentNode)) {
-					if (scopes.get(currentNode)?.has(name)) context.report({
-						message: "parameterReassignment",
-						range: getTSNodeRange(node, sourceFile)
-					});
-					return;
-				}
-				currentNode = currentNode.parent;
+		function reportParameterReassignments(node, { sourceFile }) {
+			const scopeManager = getScopeManager(sourceFile);
+			const parameterVariables = new Set(node.parameters.flatMap((parameter) => scopeManager.getDeclaredVariables(parameter)));
+			for (const reference of scopeManager.getReferencesInScope(node)) {
+				if (!reference.isWrite || !reference.variable || !parameterVariables.has(reference.variable)) continue;
+				context.report({
+					message: "parameterReassignment",
+					range: getTSNodeRange(reference.identifier, sourceFile)
+				});
 			}
-		};
-		const handleUnaryExpression = (node, { sourceFile }) => {
-			if ((node.operator === ts.SyntaxKind.PlusPlusToken || node.operator === ts.SyntaxKind.MinusMinusToken) && ts.isIdentifier(node.operand)) checkParameterAssignment(node.operand.text, node.operand, sourceFile);
-		};
+		}
 		return { visitors: {
-			ArrowFunction: (node) => {
-				scopes.set(node, collectParameterNames(node.parameters));
-			},
-			BinaryExpression: (node, { sourceFile }) => {
-				if (!(node.operatorToken.kind === ts.SyntaxKind.EqualsToken || node.operatorToken.kind === ts.SyntaxKind.PlusEqualsToken || node.operatorToken.kind === ts.SyntaxKind.MinusEqualsToken || node.operatorToken.kind === ts.SyntaxKind.AsteriskEqualsToken || node.operatorToken.kind === ts.SyntaxKind.SlashEqualsToken) || !ts.isIdentifier(node.left)) return;
-				checkParameterAssignment(node.left.text, node.left, sourceFile);
-			},
-			FunctionDeclaration: (node) => {
-				scopes.set(node, collectParameterNames(node.parameters));
-			},
-			FunctionExpression: (node) => {
-				scopes.set(node, collectParameterNames(node.parameters));
-			},
-			PostfixUnaryExpression: handleUnaryExpression,
-			PrefixUnaryExpression: handleUnaryExpression,
-			Program: () => {
-				scopes.clear();
-			}
+			ArrowFunction: reportParameterReassignments,
+			Constructor: reportParameterReassignments,
+			FunctionDeclaration: reportParameterReassignments,
+			FunctionExpression: reportParameterReassignments,
+			GetAccessor: reportParameterReassignments,
+			MethodDeclaration: reportParameterReassignments,
+			SetAccessor: reportParameterReassignments
 		} };
 	}
 });
 //#endregion
 export { parameterReassignments_default as default };
-
-//# sourceMappingURL=parameterReassignments.js.map

package/lib/rules/parseIntRadixes.d.ts

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

package/lib/rules/parseIntRadixes.js

@@ -1,21 +1,18 @@
 import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
+import { getStaticNumberValue, getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind, isIdentifier } from "typescript";
 //#region src/rules/parseIntRadixes.ts
-function isParseIntCall(node, typeChecker) {
+function isParseIntCall(node, typeChecker, program) {
 	switch (node.expression.kind) {
-		case ts$1.SyntaxKind.Identifier: return isGlobalDeclarationOfName(node.expression, "parseInt", typeChecker);
-		case ts$1.SyntaxKind.PropertyAccessExpression: return ts$1.isIdentifier(node.expression.name) && node.expression.name.text === "parseInt" && ts$1.isIdentifier(node.expression.expression) && node.expression.expression.text === "Number" && isGlobalDeclarationOfName(node.expression.expression, "Number", typeChecker);
+		case SyntaxKind.Identifier: return isGlobalDeclarationOfName(node.expression, "parseInt", typeChecker, program);
+		case SyntaxKind.PropertyAccessExpression: return isIdentifier(node.expression.name) && node.expression.name.text === "parseInt" && isIdentifier(node.expression.expression) && node.expression.expression.text === "Number" && isGlobalDeclarationOfName(node.expression.expression, "Number", typeChecker, program);
 		default: return false;
 	}
 }
 function isValidRadix(argument) {
-	switch (argument.kind) {
-		case ts$1.SyntaxKind.Identifier: return argument.text !== "undefined";
-		case ts$1.SyntaxKind.NumericLiteral: return isValidRadixValue(Number(argument.text));
-		case ts$1.SyntaxKind.PrefixUnaryExpression: return argument.operator === ts$1.SyntaxKind.MinusToken && ts$1.isNumericLiteral(argument.operand) && isValidRadixValue(-Number(argument.operand.text));
-		default: return true;
-	}
+	if (argument.kind === SyntaxKind.Identifier && argument.text === "undefined") return false;
+	const value = getStaticNumberValue(argument);
+	return value === void 0 ? true : isValidRadixValue(value);
 }
 function isValidRadixValue(value) {
 	return value >= 2 && value <= 36;
@@ -39,8 +36,8 @@ var parseIntRadixes_default = ruleCreator.createRule(typescriptLanguage, {
 		}
 	},
 	setup(context) {
-		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
-			if (!isParseIntCall(node, typeChecker)) return;
+		return { visitors: { CallExpression: (node, { program, sourceFile, typeChecker }) => {
+			if (!isParseIntCall(node, typeChecker, program)) return;
 			if (node.arguments.length <= 1) {
 				context.report({
 					message: "missingRadix",
@@ -58,5 +55,3 @@ var parseIntRadixes_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { parseIntRadixes_default as default };
-
-//# sourceMappingURL=parseIntRadixes.js.map

package/lib/rules/propertyAccessNotation.d.ts

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

package/lib/rules/propertyAccessNotation.js

@@ -1,9 +1,9 @@
 import { ruleCreator } from "./ruleCreator.js";
 import { getTSNodeRange, 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/propertyAccessNotation.ts
-const javascriptReservedWords = new Set([
+const javascriptReservedWords = /* @__PURE__ */ new Set([
 	"await",
 	"break",
 	"case",
@@ -77,7 +77,7 @@ var propertyAccessNotation_default = ruleCreator.createRule(typescriptLanguage,
 		secondary: ["Dot notation is more concise and easier to read.", "Bracket notation should only be used when the property name is not a valid identifier or is a reserved word."],
 		suggestions: ["Replace `[\"{{ key }}\"]` with `.{{ key }}`."]
 	} },
-	options: { allowIndexSignaturePropertyAccess: z.boolean().default(false).describe("Whether to allow accessing properties matching an index signature with bracket notation.") },
+	options: { allowIndexSignaturePropertyAccess: z$1.boolean().default(false).describe("Whether to allow accessing properties matching an index signature with bracket notation.") },
 	setup(context) {
 		function getKeyTypeInformation(node, typeChecker) {
 			const propertySymbol = typeChecker.getSymbolAtLocation(node.argumentExpression) ?? typeChecker.getTypeAtLocation(node.expression).getNonNullableType().getProperties().find((propertySymbol) => ts.isStringLiteral(node.argumentExpression) && propertySymbol.escapedName === node.argumentExpression.text);
@@ -115,5 +115,3 @@ var propertyAccessNotation_default = ruleCreator.createRule(typescriptLanguage,
 });
 //#endregion
 export { propertyAccessNotation_default as default };
-
-//# sourceMappingURL=propertyAccessNotation.js.map

package/lib/rules/recursionOnlyArguments.d.ts

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