@flint.fyi/ts 0.19.1 → 0.21.0

package/lib/rules/multilineAmbiguities.d.ts

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

package/lib/rules/multilineAmbiguities.js

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

package/lib/rules/namedDefaultExports.d.ts

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

package/lib/rules/namedDefaultExports.js

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

package/lib/rules/namespaceDeclarations.d.ts

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

package/lib/rules/namespaceDeclarations.js

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

package/lib/rules/namespaceImplicitAmbientImports.d.ts

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

package/lib/rules/namespaceImplicitAmbientImports.js

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

package/lib/rules/namespaceKeywords.d.ts

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

package/lib/rules/namespaceKeywords.js

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

package/lib/rules/nativeObjectExtensions.d.ts

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

package/lib/rules/nativeObjectExtensions.js

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

package/lib/rules/negativeIndexLengthMethods.d.ts

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

package/lib/rules/negativeIndexLengthMethods.js

@@ -4,7 +4,7 @@ import { isTypeRecursive } from "./utils/isTypeRecursive.js";
 import { getTSNodeRange, hasSameTokens, typescriptLanguage, unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
 import * as ts$1 from "typescript";
 //#region src/rules/negativeIndexLengthMethods.ts
-const typedArrayNames = new Set([
+const typedArrayNames = /* @__PURE__ */ new Set([
 	"BigInt64Array",
 	"BigUint64Array",
 	"Float32Array",
@@ -17,10 +17,10 @@ const typedArrayNames = new Set([
 	"Uint16Array",
 	"Uint32Array"
 ]);
-const methodConfigurations = new Map([
+const methodConfigurations = /* @__PURE__ */ new Map([
 	["at", {
 		argumentIndexes: [0],
-		supportedTypes: new Set([
+		supportedTypes: /* @__PURE__ */ new Set([
 			"Array",
 			"String",
 			...typedArrayNames
@@ -28,7 +28,7 @@ const methodConfigurations = new Map([
 	}],
 	["slice", {
 		argumentIndexes: [0, 1],
-		supportedTypes: new Set([
+		supportedTypes: /* @__PURE__ */ new Set([
 			"Array",
 			"String",
 			...typedArrayNames
@@ -36,7 +36,7 @@ const methodConfigurations = new Map([
 	}],
 	["splice", {
 		argumentIndexes: [0],
-		supportedTypes: new Set(["Array"])
+		supportedTypes: /* @__PURE__ */ new Set(["Array"])
 	}],
 	["subarray", {
 		argumentIndexes: [0, 1],
@@ -44,11 +44,11 @@ const methodConfigurations = new Map([
 	}],
 	["toSpliced", {
 		argumentIndexes: [0],
-		supportedTypes: new Set(["Array"])
+		supportedTypes: /* @__PURE__ */ new Set(["Array"])
 	}],
 	["with", {
 		argumentIndexes: [0],
-		supportedTypes: new Set(["Array", ...typedArrayNames])
+		supportedTypes: /* @__PURE__ */ new Set(["Array", ...typedArrayNames])
 	}]
 ]);
 function getNegativeIndexLengthNode(node, target, sourceFile) {
@@ -176,5 +176,3 @@ var negativeIndexLengthMethods_default = ruleCreator.createRule(typescriptLangua
 });
 //#endregion
 export { negativeIndexLengthMethods_default as default };
-
-//# sourceMappingURL=negativeIndexLengthMethods.js.map

package/lib/rules/negativeZeroComparisons.d.ts

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

package/lib/rules/negativeZeroComparisons.js

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

package/lib/rules/nestedStandaloneIfs.d.ts

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

package/lib/rules/nestedStandaloneIfs.js

@@ -9,7 +9,7 @@ function hasCommentsInRange(sourceFile, start, end) {
 function isIfWithoutElse(node) {
 	return ts.isIfStatement(node) && node.elseStatement === void 0;
 }
-const lowerPrecedenceThanLogicalAnd = new Set([
+const lowerPrecedenceThanLogicalAnd = /* @__PURE__ */ new Set([
 	SyntaxKind.BinaryExpression,
 	SyntaxKind.ConditionalExpression,
 	SyntaxKind.YieldExpression
@@ -101,5 +101,3 @@ var nestedStandaloneIfs_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { nestedStandaloneIfs_default as default };
-
-//# sourceMappingURL=nestedStandaloneIfs.js.map

package/lib/rules/newDefinitions.d.ts

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

package/lib/rules/newDefinitions.js

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

package/lib/rules/newExpressions.d.ts

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

package/lib/rules/newExpressions.js

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

package/lib/rules/newNativeNonConstructors.d.ts

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

package/lib/rules/newNativeNonConstructors.js

@@ -14,10 +14,10 @@ var newNativeNonConstructors_default = ruleCreator.createRule(typescriptLanguage
 		suggestions: ["Remove the `new` keyword and call the function directly."]
 	} },
 	setup(context) {
-		return { visitors: { NewExpression: (node, { sourceFile, typeChecker }) => {
+		return { visitors: { NewExpression: (node, { program, sourceFile, typeChecker }) => {
 			if (node.expression.kind !== SyntaxKind.Identifier) return;
 			const name = node.expression.text;
-			if (!["BigInt", "Symbol"].includes(name) || !isGlobalDeclaration(node.expression, typeChecker)) return;
+			if (!["BigInt", "Symbol"].includes(name) || !isGlobalDeclaration(node.expression, typeChecker, program)) return;
 			context.report({
 				data: { name },
 				fix: {
@@ -35,5 +35,3 @@ var newNativeNonConstructors_default = ruleCreator.createRule(typescriptLanguage
 });
 //#endregion
 export { newNativeNonConstructors_default as default };
-
-//# sourceMappingURL=newNativeNonConstructors.js.map

package/lib/rules/nonNullAssertedNullishCoalesces.d.ts

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

package/lib/rules/nonNullAssertedNullishCoalesces.js

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

package/lib/rules/nonNullAssertedOptionalChains.d.ts

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

package/lib/rules/nonNullAssertedOptionalChains.js

@@ -65,5 +65,3 @@ var nonNullAssertedOptionalChains_default = ruleCreator.createRule(typescriptLan
 });
 //#endregion
 export { nonNullAssertedOptionalChains_default as default };
-
-//# sourceMappingURL=nonNullAssertedOptionalChains.js.map

package/lib/rules/nonNullAssertionPlacement.d.ts

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

package/lib/rules/nonNullAssertionPlacement.js

@@ -5,7 +5,7 @@ import { SyntaxKind } from "typescript";
 function endsWithNonNullAssertion(node, sourceFile) {
 	return node.getLastToken(sourceFile)?.kind === SyntaxKind.ExclamationToken;
 }
-const confusingOperatorTexts = new Map([
+const confusingOperatorTexts = /* @__PURE__ */ new Map([
 	[SyntaxKind.EqualsEqualsEqualsToken, "==="],
 	[SyntaxKind.EqualsEqualsToken, "=="],
 	[SyntaxKind.EqualsToken, "="],
@@ -90,5 +90,3 @@ var nonNullAssertionPlacement_default = ruleCreator.createRule(typescriptLanguag
 });
 //#endregion
 export { nonNullAssertionPlacement_default as default };
-
-//# sourceMappingURL=nonNullAssertionPlacement.js.map

package/lib/rules/nonNullableTypeAssertions.d.ts

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

package/lib/rules/nonNullableTypeAssertions.js

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

package/lib/rules/nonOctalDecimalEscapes.d.ts

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

package/lib/rules/nonOctalDecimalEscapes.js

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

package/lib/rules/nullishCheckStyle.d.ts

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

package/lib/rules/nullishCheckStyle.js

@@ -2,7 +2,7 @@ import { ruleCreator } from "./ruleCreator.js";
 import { isNullishLiteral, isUndefinedIdentifier, toEqualityOperator, toLooseOperator, toStrictOperator } from "./utils/equalityOperators.js";
 import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
 import { isNullKeyword } from "ts-api-utils";
-import { z } from "zod/v4";
+import { z as z$1 } from "zod/v4";
 //#region src/rules/nullishCheckStyle.ts
 var nullishCheckStyle_default = ruleCreator.createRule(typescriptLanguage, {
 	about: {
@@ -32,12 +32,12 @@ var nullishCheckStyle_default = ruleCreator.createRule(typescriptLanguage, {
 		}
 	},
 	options: {
-		looseNullishComparisonStyle: z.enum([
+		looseNullishComparisonStyle: z$1.enum([
 			"prefer-null",
 			"prefer-undefined",
 			"ignore"
 		]).default("prefer-null"),
-		nullishComparisonStrictness: z.enum([
+		nullishComparisonStrictness: z$1.enum([
 			"double-equals",
 			"triple-equals",
 			"ignore"
@@ -140,5 +140,3 @@ var nullishCheckStyle_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { nullishCheckStyle_default as default };
-
-//# sourceMappingURL=nullishCheckStyle.js.map

package/lib/rules/nullishCoalescingOperators.d.ts

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

package/lib/rules/nullishCoalescingOperators.js

@@ -2,7 +2,7 @@ import { ruleCreator } from "./ruleCreator.js";
 import { getTSNodeRange, hasSameTokens, typescriptLanguage } from "@flint.fyi/typescript-language";
 import ts from "typescript";
 import * as tsutils from "ts-api-utils";
-import { z } from "zod/v4";
+import { z as z$1 } from "zod/v4";
 //#region src/rules/nullishCoalescingOperators.ts
 function analyzeConditionalForNullish(node, sourceFile) {
 	const { condition, whenFalse, whenTrue } = node;
@@ -111,6 +111,17 @@ function getComparisonOperator(node) {
 		default: return "";
 	}
 }
+function getIfStatementNullishCheckValue(node) {
+	switch (node.expression.kind) {
+		case ts.SyntaxKind.BinaryExpression:
+			if (isNullLikeComparison(node.expression)) return extractValueFromComparison(node.expression).value ?? void 0;
+			return;
+		case ts.SyntaxKind.PrefixUnaryExpression:
+			if (node.expression.operator === ts.SyntaxKind.ExclamationToken) return node.expression.operand;
+			return;
+		default: return;
+	}
+}
 function getTypeFlags(type) {
 	let flags = 0;
 	for (const constituent of tsutils.unionConstituents(type)) for (const subConstituent of tsutils.intersectionConstituents(constituent)) flags |= subConstituent.getFlags();
@@ -143,13 +154,6 @@ function isFalsyLiteralType(part) {
 	}
 	return false;
 }
-function isIfStatementNullishCheck(node) {
-	switch (node.expression.kind) {
-		case ts.SyntaxKind.BinaryExpression: return isNullLikeComparison(node.expression);
-		case ts.SyntaxKind.PrefixUnaryExpression: return node.expression.operator === ts.SyntaxKind.ExclamationToken;
-		default: return false;
-	}
-}
 function isMixedLogicalExpression(node) {
 	const seen = /* @__PURE__ */ new Set();
 	const queue = [
@@ -224,21 +228,21 @@ var nullishCoalescingOperators_default = ruleCreator.createRule(typescriptLangua
 		}
 	},
 	options: {
-		ignoreConditionalTests: z.boolean().default(true).describe("Whether to skip cases where the expression is in a conditional context."),
-		ignoreIfStatements: z.boolean().default(false).describe("Whether to skip if statement patterns with nullish checks."),
-		ignoreMixedLogicalExpressions: z.boolean().default(false).describe("Whether to skip expressions that mix && and || operators."),
-		ignorePrimitives: z.union([z.boolean(), z.record(z.enum([
+		ignoreConditionalTests: z$1.boolean().default(true).describe("Whether to skip cases where the expression is in a conditional context."),
+		ignoreIfStatements: z$1.boolean().default(false).describe("Whether to skip if statement patterns with nullish checks."),
+		ignoreMixedLogicalExpressions: z$1.boolean().default(false).describe("Whether to skip expressions that mix && and || operators."),
+		ignorePrimitives: z$1.union([z$1.boolean(), z$1.record(z$1.enum([
 			"bigint",
 			"boolean",
 			"number",
 			"string"
-		]), z.boolean())]).default({
+		]), z$1.boolean())]).default({
 			bigint: false,
 			boolean: false,
 			number: false,
 			string: false
 		}).describe("Whether to skip primitive types. Can be a boolean or an object with per-type configuration."),
-		ignoreTernaryTests: z.boolean().default(false).describe("Whether to skip ternary expressions.")
+		ignoreTernaryTests: z$1.boolean().default(false).describe("Whether to skip ternary expressions.")
 	},
 	setup(context) {
 		function getOptionalChainInsertPosition(node, test, sourceFile) {
@@ -266,6 +270,13 @@ var nullishCoalescingOperators_default = ruleCreator.createRule(typescriptLangua
 				text: `${leftText} ?? ${getText(alternate)}`
 			};
 		}
+		function createNullishAssignmentFix(left, right, sourceFile, range) {
+			const getText = (node) => sourceFile.text.substring(node.getStart(sourceFile), node.getEnd());
+			return {
+				range,
+				text: `${getText(left)} ??= ${getText(right)};`
+			};
+		}
 		return { visitors: {
 			BinaryExpression: (node, { options, sourceFile, typeChecker }) => {
 				if (options.ignoreConditionalTests && isConditionalTest(node) || options.ignoreMixedLogicalExpressions && isMixedLogicalExpression(node) || ![ts.SyntaxKind.BarBarEqualsToken, ts.SyntaxKind.BarBarToken].includes(node.operatorToken.kind) || shouldIgnoreNode(node.left, options.ignorePrimitives, typeChecker)) return;
@@ -292,12 +303,13 @@ var nullishCoalescingOperators_default = ruleCreator.createRule(typescriptLangua
 				});
 			},
 			IfStatement: (node, { options, sourceFile, typeChecker }) => {
-				if (options.ignoreIfStatements || node.elseStatement || !isIfStatementNullishCheck(node)) return;
+				const checkedValue = getIfStatementNullishCheckValue(node);
+				if (options.ignoreIfStatements || node.elseStatement || !checkedValue) return;
 				const assignmentExpression = extractAssignmentFromIfStatement(node);
-				if (!assignmentExpression || shouldIgnoreNode(assignmentExpression.left, options.ignorePrimitives, typeChecker)) return;
+				if (!assignmentExpression || !hasSameTokens(assignmentExpression.left, checkedValue, sourceFile) || shouldIgnoreNode(assignmentExpression.left, options.ignorePrimitives, typeChecker)) return;
 				const range = getTSNodeRange(node, sourceFile);
 				context.report({
-					fix: createNullishNodesFix(assignmentExpression.left, assignmentExpression.right, sourceFile, range),
+					fix: createNullishAssignmentFix(assignmentExpression.left, assignmentExpression.right, sourceFile, range),
 					message: "preferNullishAssignment",
 					range
 				});
@@ -307,5 +319,3 @@ var nullishCoalescingOperators_default = ruleCreator.createRule(typescriptLangua
 });
 //#endregion
 export { nullishCoalescingOperators_default as default };
-
-//# sourceMappingURL=nullishCoalescingOperators.js.map

package/lib/rules/numberMethodRanges.d.ts

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

package/lib/rules/numberMethodRanges.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/numberMethodRanges.ts
-const methodSpecs = new Map([
+const methodSpecs = /* @__PURE__ */ new Map([
 	["toExponential", {
 		max: 100,
 		min: 0,
@@ -70,5 +70,3 @@ var numberMethodRanges_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { numberMethodRanges_default as default };
-
-//# sourceMappingURL=numberMethodRanges.js.map

package/lib/rules/numberStaticMethods.d.ts

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

package/lib/rules/numberStaticMethods.js

@@ -2,7 +2,7 @@ import { ruleCreator } from "./ruleCreator.js";
 import { getTSNodeRange, isGlobalVariable, typescriptLanguage } from "@flint.fyi/typescript-language";
 import ts from "typescript";
 //#region src/rules/numberStaticMethods.ts
-const globalReplacements = new Map([["isFinite", "Number.isFinite"], ["isNaN", "Number.isNaN"]]);
+const globalReplacements = /* @__PURE__ */ new Map([["isFinite", "Number.isFinite"], ["isNaN", "Number.isNaN"]]);
 function isDeclarationName(node) {
 	return ts.isFunctionDeclaration(node.parent) && node.parent.name === node || ts.isVariableDeclaration(node.parent) && node.parent.name === node || ts.isParameter(node.parent) && node.parent.name === node;
 }
@@ -27,9 +27,9 @@ var numberStaticMethods_default = ruleCreator.createRule(typescriptLanguage, {
 		suggestions: ["Replace `{{ name }}` with `{{ replacement }}`."]
 	} },
 	setup(context) {
-		return { visitors: { Identifier: (node, { sourceFile, typeChecker }) => {
+		return { visitors: { Identifier: (node, { program, sourceFile, typeChecker }) => {
 			const replacement = globalReplacements.get(node.text);
-			if (!replacement || isPropertyAccessOfNode(node) || isPropertyShorthandOfNode(node) || isDeclarationName(node) || !isGlobalVariable(node, typeChecker) || isLeftHandSide(node)) return;
+			if (!replacement || isPropertyAccessOfNode(node) || isPropertyShorthandOfNode(node) || isDeclarationName(node) || !isGlobalVariable(node, typeChecker, program) || isLeftHandSide(node)) return;
 			const range = getTSNodeRange(node, sourceFile);
 			context.report({
 				data: {
@@ -49,5 +49,3 @@ var numberStaticMethods_default = ruleCreator.createRule(typescriptLanguage, {
 });
 //#endregion
 export { numberStaticMethods_default as default };
-
-//# sourceMappingURL=numberStaticMethods.js.map

package/lib/rules/numericErasingOperations.d.ts

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

package/lib/rules/numericErasingOperations.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 ts from "typescript";
 //#region src/rules/numericErasingOperations.ts
 function isZeroLiteral(node) {
-	return node.kind === ts.SyntaxKind.NumericLiteral && node.text === "0";
+	return Object.is(getStaticNumberValue(node), 0);
 }
 var numericErasingOperations_default = ruleCreator.createRule(typescriptLanguage, {
 	about: {
@@ -42,5 +42,3 @@ var numericErasingOperations_default = ruleCreator.createRule(typescriptLanguage
 });
 //#endregion
 export { numericErasingOperations_default as default };
-
-//# sourceMappingURL=numericErasingOperations.js.map

package/lib/rules/numericLiteralParsing.d.ts

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