@flint.fyi/ts 0.20.0 → 0.22.0

package/lib/rules/nonNullableTypeAssertions.js

@@ -1,78 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-import * as tsutils from "ts-api-utils";
-//#region src/rules/nonNullableTypeAssertions.ts
-function couldBeNullish(type) {
-	if (type.flags & ts.TypeFlags.TypeParameter) {
-		const constraint = type.getConstraint();
-		return constraint === void 0 || couldBeNullish(constraint);
-	}
-	if (tsutils.isUnionType(type)) return type.types.some(couldBeNullish);
-	return (type.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)) !== 0;
-}
-function getTypesIfNotLoose(node, typeChecker) {
-	const type = typeChecker.getTypeAtLocation(node);
-	if (tsutils.isTypeFlagSet(type, ts.TypeFlags.Any | ts.TypeFlags.Unknown)) return;
-	return tsutils.unionConstituents(type);
-}
-function isConstAssertion(node, sourceFile) {
-	return node.type.kind === ts.SyntaxKind.TypeReference && node.type.typeName.kind === ts.SyntaxKind.Identifier && node.type.typeName.getText(sourceFile) === "const";
-}
-function needsParentheses(expression) {
-	switch (expression.kind) {
-		case ts.SyntaxKind.ArrowFunction:
-		case ts.SyntaxKind.AwaitExpression:
-		case ts.SyntaxKind.BinaryExpression:
-		case ts.SyntaxKind.ConditionalExpression:
-		case ts.SyntaxKind.PrefixUnaryExpression:
-		case ts.SyntaxKind.YieldExpression: return true;
-		default: return false;
-	}
-}
-function sameTypeWithoutNullish(assertedTypes, originalTypes) {
-	const nonNullishOriginalTypes = originalTypes.filter((type) => (type.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)) === 0);
-	if (nonNullishOriginalTypes.length === originalTypes.length) return false;
-	for (const assertedType of assertedTypes) if (couldBeNullish(assertedType) || !nonNullishOriginalTypes.includes(assertedType)) return false;
-	for (const originalType of nonNullishOriginalTypes) if (!assertedTypes.includes(originalType)) return false;
-	return true;
-}
-var nonNullableTypeAssertions_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports type assertions that can be replaced with non-null assertions.",
-		id: "nonNullableTypeAssertions",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { preferNonNullAssertion: {
-		primary: "Use a non-null assertion (`!`) instead of an explicit type assertion.",
-		secondary: ["When the only difference between the original and asserted type is nullability, a non-null assertion is more concise.", "Non-null assertions clearly communicate that you're asserting the value is not null or undefined."],
-		suggestions: ["Replace the type assertion with a `!` assertion."]
-	} },
-	setup(context) {
-		function checkNode(node, { sourceFile, typeChecker }) {
-			if (isConstAssertion(node, sourceFile)) return;
-			const originalTypes = getTypesIfNotLoose(node.expression, typeChecker);
-			if (!originalTypes) return;
-			const assertedTypes = getTypesIfNotLoose(node.type, typeChecker);
-			if (!assertedTypes || !sameTypeWithoutNullish(assertedTypes, originalTypes)) return;
-			const expressionText = node.expression.getText(sourceFile);
-			const replacement = needsParentheses(node.expression) ? `(${expressionText})!` : `${expressionText}!`;
-			context.report({
-				fix: {
-					range: getTSNodeRange(node, sourceFile),
-					text: replacement
-				},
-				message: "preferNonNullAssertion",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		}
-		return { visitors: {
-			AsExpression: checkNode,
-			TypeAssertionExpression: checkNode
-		} };
-	}
-});
-//#endregion
-export { nonNullableTypeAssertions_default as default };
-
-//# sourceMappingURL=nonNullableTypeAssertions.js.map

package/lib/rules/nonOctalDecimalEscapes.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports non-octal decimal escape sequences (\\8 and \\9) in string literals.";
-    readonly id: "nonOctalDecimalEscapes";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unexpectedEscape", undefined>;
-export default _default;
-//# sourceMappingURL=nonOctalDecimalEscapes.d.ts.map

package/lib/rules/nonOctalDecimalEscapes.js

@@ -1,48 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/nonOctalDecimalEscapes.ts
-const nonOctalDecimalEscapePattern = /\\[89]/g;
-var nonOctalDecimalEscapes_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports non-octal decimal escape sequences (\\8 and \\9) in string literals.",
-		id: "nonOctalDecimalEscapes",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { unexpectedEscape: {
-		primary: "Non-octal decimal escape sequences (\\8 and \\9) should not be used in string literals.",
-		secondary: [
-			"Non-octal decimal escape sequences \\8 and \\9 are legacy features that are treated as identity escapes (the same as the literal digits).",
-			"They are optional in the ECMAScript specification and not supported in strict mode in all environments.",
-			"Use the literal digits directly instead."
-		],
-		suggestions: ["Remove the backslash to use the literal digit.", "If an escape sequence is needed, use a Unicode escape like \\u0038 or \\u0039."]
-	} },
-	setup(context) {
-		function checkNode(node, { sourceFile }) {
-			const text = node.getText(sourceFile);
-			const matches = [...text.matchAll(nonOctalDecimalEscapePattern)];
-			for (const match of matches) {
-				const matchIndex = match.index;
-				let backslashesBefore = 0;
-				for (let i = matchIndex - 1; i >= 0 && text[i] === "\\"; i--) backslashesBefore++;
-				if (backslashesBefore % 2 === 1) continue;
-				const start = node.getStart(sourceFile) + matchIndex;
-				context.report({
-					message: "unexpectedEscape",
-					range: {
-						begin: start,
-						end: start + match[0].length
-					}
-				});
-			}
-		}
-		return { visitors: {
-			NoSubstitutionTemplateLiteral: checkNode,
-			StringLiteral: checkNode
-		} };
-	}
-});
-//#endregion
-export { nonOctalDecimalEscapes_default as default };
-
-//# sourceMappingURL=nonOctalDecimalEscapes.js.map

package/lib/rules/nullishCheckStyle.d.ts

@@ -1,21 +0,0 @@
-import { z } from "zod/v4";
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Enforces consistent equality operator usage when comparing with null or undefined.";
-    readonly id: "nullishCheckStyle";
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferLooseNull" | "preferLooseNullish" | "preferLooseUndefined" | "preferStrictNullish", {
-    looseNullishComparisonStyle: z.ZodDefault<z.ZodEnum<{
-        "prefer-null": "prefer-null";
-        "prefer-undefined": "prefer-undefined";
-        ignore: "ignore";
-    }>>;
-    nullishComparisonStrictness: z.ZodDefault<z.ZodEnum<{
-        ignore: "ignore";
-        "double-equals": "double-equals";
-        "triple-equals": "triple-equals";
-    }>>;
-}>;
-export default _default;
-//# sourceMappingURL=nullishCheckStyle.d.ts.map

package/lib/rules/nullishCheckStyle.js

@@ -1,144 +0,0 @@
-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";
-//#region src/rules/nullishCheckStyle.ts
-var nullishCheckStyle_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Enforces consistent equality operator usage when comparing with null or undefined.",
-		id: "nullishCheckStyle"
-	},
-	messages: {
-		preferLooseNull: {
-			primary: "Compare with 'null' rather than 'undefined'.",
-			secondary: ["`x == null` and `x == undefined` are equivalent to each other; both check `x === null || x === undefined`.", "Use `x == null` since it is shorter."],
-			suggestions: ["Replace 'undefined' with 'null'."]
-		},
-		preferLooseNullish: {
-			primary: "Use loose equality ('{{ looseOperator }}') for nullish comparisons.",
-			secondary: ["When checking for nullish values (null or undefined), loose equality is more concise.", "`x == null` checks for both null and undefined, equivalent to `x === null || x === undefined`."],
-			suggestions: ["Replace '{{ strictOperator }}' with '{{ looseOperator }}'."]
-		},
-		preferLooseUndefined: {
-			primary: "Compare with 'undefined' rather than 'null'.",
-			secondary: ["`x == null` and `x == undefined` are equivalent to each other; both check `x === null || x === undefined`.", "Use `x == undefined`."],
-			suggestions: ["Replace 'null' with 'undefined'."]
-		},
-		preferStrictNullish: {
-			primary: "Use strict equality ('{{ strictOperator }}') for nullish comparisons.",
-			secondary: ["When nullish comparison strictness is set to 'strict', use strict equality operators for nullish comparisons."],
-			suggestions: ["Replace '{{ looseOperator }}' with '{{ strictOperator }}'."]
-		}
-	},
-	options: {
-		looseNullishComparisonStyle: z.enum([
-			"prefer-null",
-			"prefer-undefined",
-			"ignore"
-		]).default("prefer-null"),
-		nullishComparisonStrictness: z.enum([
-			"double-equals",
-			"triple-equals",
-			"ignore"
-		]).default("double-equals")
-	},
-	setup(context) {
-		return { visitors: { BinaryExpression: (node, { options, sourceFile }) => {
-			const operator = toEqualityOperator(node.operatorToken.kind);
-			if (operator == null) return;
-			const leftIsNullish = isNullishLiteral(node.left);
-			if (leftIsNullish === isNullishLiteral(node.right)) return;
-			const isLooseComparison = operator === "==" || operator === "!=";
-			if (options.nullishComparisonStrictness === "double-equals" && !isLooseComparison) {
-				const looseOperator = toLooseOperator(operator);
-				const operatorRange = getTSNodeRange(node.operatorToken, sourceFile);
-				context.report({
-					data: {
-						looseOperator,
-						strictOperator: operator
-					},
-					message: "preferLooseNullish",
-					range: leftIsNullish ? {
-						begin: node.left.getStart(sourceFile),
-						end: operatorRange.end
-					} : {
-						begin: operatorRange.begin,
-						end: node.right.getEnd()
-					},
-					suggestions: [{
-						id: "useLooseOperator",
-						range: operatorRange,
-						text: looseOperator
-					}]
-				});
-				return;
-			}
-			if (options.nullishComparisonStrictness === "triple-equals" && isLooseComparison) {
-				const strictOperator = toStrictOperator(operator);
-				const operatorRange = getTSNodeRange(node.operatorToken, sourceFile);
-				context.report({
-					data: {
-						looseOperator: operator,
-						strictOperator
-					},
-					message: "preferStrictNullish",
-					range: leftIsNullish ? {
-						begin: node.left.getStart(sourceFile),
-						end: operatorRange.end
-					} : {
-						begin: operatorRange.begin,
-						end: node.right.getEnd()
-					},
-					suggestions: [{
-						id: "useStrictOperator",
-						range: operatorRange,
-						text: strictOperator
-					}]
-				});
-				return;
-			}
-			if (isLooseComparison) {
-				if (options.looseNullishComparisonStyle === "prefer-null") {
-					const leftIsUndefined = isUndefinedIdentifier(node.left);
-					const rightIsUndefined = isUndefinedIdentifier(node.right);
-					if (leftIsUndefined || rightIsUndefined) context.report({
-						fix: [{
-							range: getTSNodeRange(leftIsUndefined ? node.left : node.right, sourceFile),
-							text: "null"
-						}],
-						message: "preferLooseNull",
-						range: leftIsUndefined ? {
-							begin: node.left.getStart(sourceFile),
-							end: node.operatorToken.getEnd()
-						} : {
-							begin: node.operatorToken.getStart(sourceFile),
-							end: node.right.getEnd()
-						}
-					});
-				} else if (options.looseNullishComparisonStyle === "prefer-undefined") {
-					const leftIsNull = isNullKeyword(node.left);
-					const rightIsNull = isNullKeyword(node.right);
-					if (leftIsNull || rightIsNull) context.report({
-						fix: [{
-							range: getTSNodeRange(leftIsNull ? node.left : node.right, sourceFile),
-							text: "undefined"
-						}],
-						message: "preferLooseUndefined",
-						range: leftIsNull ? {
-							begin: node.left.getStart(sourceFile),
-							end: node.operatorToken.getEnd()
-						} : {
-							begin: node.operatorToken.getStart(sourceFile),
-							end: node.right.getEnd()
-						}
-					});
-				}
-			}
-		} } };
-	}
-});
-//#endregion
-export { nullishCheckStyle_default as default };
-
-//# sourceMappingURL=nullishCheckStyle.js.map

package/lib/rules/nullishCoalescingOperators.d.ts

@@ -1,22 +0,0 @@
-import { z } from "zod/v4";
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Prefer nullish coalescing operator (??) over logical OR (||) for nullish values.";
-    readonly id: "nullishCoalescingOperators";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferNullish" | "preferNullishAssignment" | "preferNullishTernary", {
-    ignoreConditionalTests: z.ZodDefault<z.ZodBoolean>;
-    ignoreIfStatements: z.ZodDefault<z.ZodBoolean>;
-    ignoreMixedLogicalExpressions: z.ZodDefault<z.ZodBoolean>;
-    ignorePrimitives: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodRecord<z.ZodEnum<{
-        string: "string";
-        number: "number";
-        bigint: "bigint";
-        boolean: "boolean";
-    }>, z.ZodBoolean>]>>;
-    ignoreTernaryTests: z.ZodDefault<z.ZodBoolean>;
-}>;
-export default _default;
-//# sourceMappingURL=nullishCoalescingOperators.d.ts.map

package/lib/rules/nullishCoalescingOperators.js

@@ -1,323 +0,0 @@
-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";
-//#region src/rules/nullishCoalescingOperators.ts
-function analyzeConditionalForNullish(node, sourceFile) {
-	const { condition, whenFalse, whenTrue } = node;
-	if (ts.isIdentifier(condition) && ts.isIdentifier(whenTrue) && condition.text === whenTrue.text) return {
-		alternate: whenFalse,
-		consequent: whenTrue,
-		operator: "",
-		test: condition
-	};
-	if (ts.isPrefixUnaryExpression(condition) && condition.operator === ts.SyntaxKind.ExclamationToken) {
-		const operand = condition.operand;
-		if (ts.isIdentifier(operand) && ts.isIdentifier(whenFalse) && operand.text === whenFalse.text) return {
-			alternate: whenTrue,
-			consequent: whenFalse,
-			operator: "!",
-			test: operand
-		};
-	}
-	if (ts.isBinaryExpression(condition) && isNullLikeComparison(condition)) {
-		const { isNegation, value: testValue } = extractValueFromComparison(condition);
-		if (!testValue) return {};
-		const operator = getComparisonOperator(condition);
-		const [alternate, consequent] = isNegation ? [whenFalse, whenTrue] : [whenTrue, whenFalse];
-		if (!consequentMatchesTest(consequent, testValue, sourceFile)) return {};
-		return {
-			alternate,
-			consequent,
-			operator,
-			test: testValue
-		};
-	}
-	if (ts.isBinaryExpression(condition) && condition.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
-		const leftIsComparison = ts.isBinaryExpression(condition.left) ? isNullLikeComparison(condition.left) : false;
-		const rightIsComparison = ts.isBinaryExpression(condition.right) ? isNullLikeComparison(condition.right) : false;
-		if (leftIsComparison && rightIsComparison) {
-			const leftComp = condition.left;
-			const rightComp = condition.right;
-			const leftValue = extractValueFromComparison(leftComp).value;
-			const rightValue = extractValueFromComparison(rightComp).value;
-			if (leftValue && rightValue && hasSameTokens(leftValue, rightValue, sourceFile)) return {
-				alternate: whenFalse,
-				consequent: whenTrue,
-				operator: "===",
-				test: leftValue
-			};
-		}
-	}
-	if (ts.isBinaryExpression(condition) && condition.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
-		const leftIsComparison = ts.isBinaryExpression(condition.left) ? isNullLikeComparison(condition.left) : false;
-		const rightIsComparison = ts.isBinaryExpression(condition.right) ? isNullLikeComparison(condition.right) : false;
-		if (leftIsComparison && rightIsComparison) {
-			const leftComp = condition.left;
-			const rightComp = condition.right;
-			const leftValue = extractValueFromComparison(leftComp).value;
-			const rightValue = extractValueFromComparison(rightComp).value;
-			if (leftValue && rightValue && hasSameTokens(leftValue, rightValue, sourceFile)) return {
-				alternate: whenTrue,
-				consequent: whenFalse,
-				operator: "===",
-				test: leftValue
-			};
-		}
-	}
-	return {};
-}
-function consequentMatchesTest(consequent, test, sourceFile) {
-	if (hasSameTokens(consequent, test, sourceFile)) return true;
-	if (ts.isPropertyAccessExpression(consequent) || ts.isElementAccessExpression(consequent) || ts.isCallExpression(consequent)) return consequentMatchesTest(consequent.expression, test, sourceFile);
-	return false;
-}
-function extractAssignmentFromIfStatement(node) {
-	let assignmentExpr;
-	if (ts.isBlock(node.thenStatement)) {
-		if (node.thenStatement.statements.length === 1) {
-			const stmt = node.thenStatement.statements[0];
-			if (stmt && ts.isExpressionStatement(stmt)) assignmentExpr = stmt.expression;
-		}
-	} else if (ts.isExpressionStatement(node.thenStatement)) assignmentExpr = node.thenStatement.expression;
-	if (!assignmentExpr || !ts.isBinaryExpression(assignmentExpr) || assignmentExpr.operatorToken.kind !== ts.SyntaxKind.EqualsToken) return;
-	return {
-		left: assignmentExpr.left,
-		right: assignmentExpr.right
-	};
-}
-function extractValueFromComparison(node) {
-	const isNegation = node.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsToken || node.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken;
-	if (isNullLike(node.left)) return {
-		isNegation,
-		value: node.right
-	};
-	if (isNullLike(node.right)) return {
-		isNegation,
-		value: node.left
-	};
-	return {
-		isNegation,
-		value: null
-	};
-}
-function getComparisonOperator(node) {
-	switch (node.operatorToken.kind) {
-		case ts.SyntaxKind.EqualsEqualsEqualsToken: return "===";
-		case ts.SyntaxKind.EqualsEqualsToken: return "==";
-		case ts.SyntaxKind.ExclamationEqualsEqualsToken: return "!==";
-		case ts.SyntaxKind.ExclamationEqualsToken: return "!=";
-		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();
-	return flags;
-}
-function isConditionalTest(node) {
-	switch (node.parent.kind) {
-		case ts.SyntaxKind.BinaryExpression:
-			if (node.parent.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken || node.parent.operatorToken.kind === ts.SyntaxKind.BarBarToken) return isConditionalTest(node.parent);
-			return false;
-		case ts.SyntaxKind.ConditionalExpression: return node.parent.condition === node || isConditionalTest(node.parent);
-		case ts.SyntaxKind.DoStatement:
-		case ts.SyntaxKind.IfStatement:
-		case ts.SyntaxKind.WhileStatement: return node.parent.expression === node;
-		case ts.SyntaxKind.ForStatement: return node.parent.condition === node;
-		case ts.SyntaxKind.PrefixUnaryExpression: return node.parent.operator === ts.SyntaxKind.ExclamationToken && isConditionalTest(node.parent);
-		default: return false;
-	}
-}
-function isFalsyLiteralType(part) {
-	if (part.isNumberLiteral() && part.value === 0) return true;
-	if (part.isStringLiteral() && part.value === "") return true;
-	const flags = part.getFlags();
-	if (flags & ts.TypeFlags.BooleanLiteral) {
-		if (part.intrinsicName === "false") return true;
-	}
-	if (flags & ts.TypeFlags.BigIntLiteral) {
-		const value = part.value;
-		if (!value.negative && value.base10Value === "0") return true;
-	}
-	return false;
-}
-function isMixedLogicalExpression(node) {
-	const seen = /* @__PURE__ */ new Set();
-	const queue = [
-		node.parent,
-		node.left,
-		node.right
-	];
-	for (const current of queue) {
-		if (!seen.has(current)) continue;
-		seen.add(current);
-		if (ts.isBinaryExpression(current)) {
-			if (current.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) return true;
-			if (current.operatorToken.kind === ts.SyntaxKind.BarBarToken || current.operatorToken.kind === ts.SyntaxKind.BarBarEqualsToken) queue.push(current.parent, current.left, current.right);
-		}
-	}
-	return false;
-}
-function isNullishType(type) {
-	return tsutils.isTypeFlagSet(type, ts.TypeFlags.Null | ts.TypeFlags.Undefined);
-}
-function isNullLike(node) {
-	switch (node.kind) {
-		case ts.SyntaxKind.Identifier: return node.text === "undefined";
-		case ts.SyntaxKind.NullKeyword: return true;
-		default: return false;
-	}
-}
-function isNullLikeComparison(node) {
-	return (node.operatorToken.kind === ts.SyntaxKind.EqualsEqualsToken || node.operatorToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken || node.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsToken || node.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken) && (isNullLike(node.left) || isNullLike(node.right));
-}
-function isTypeEligibleForPreferNullish(type, ignorePrimitives) {
-	if (!typeCanBeNullish(type) || tsutils.isTypeFlagSet(type, ts.TypeFlags.Any | ts.TypeFlags.Unknown) || !ignorePrimitives) return true;
-	const ignorableFlags = [
-		(ignorePrimitives === true || typeof ignorePrimitives === "object" && ignorePrimitives.bigint) && ts.TypeFlags.BigIntLike,
-		(ignorePrimitives === true || typeof ignorePrimitives === "object" && ignorePrimitives.boolean) && ts.TypeFlags.BooleanLike,
-		(ignorePrimitives === true || typeof ignorePrimitives === "object" && ignorePrimitives.number) && ts.TypeFlags.NumberLike,
-		(ignorePrimitives === true || typeof ignorePrimitives === "object" && ignorePrimitives.string) && ts.TypeFlags.StringLike
-	].filter((flag) => typeof flag === "number").reduce((previous, flag) => previous | flag, 0);
-	return ignorableFlags === 0 || !(getTypeFlags(type) & ignorableFlags);
-}
-function shouldIgnoreNode(node, ignorePrimitives, typeChecker) {
-	const type = typeChecker.getTypeAtLocation(node);
-	return tsutils.isTypeFlagSet(type, ts.TypeFlags.Any | ts.TypeFlags.Unknown) || !typeCanBeNullish(type) || typeHasNonNullishFalsyValues(type) || !isTypeEligibleForPreferNullish(type, ignorePrimitives);
-}
-function typeCanBeNullish(type) {
-	return tsutils.unionConstituents(type).some(isNullishType);
-}
-function typeHasNonNullishFalsyValues(type) {
-	return tsutils.unionConstituents(type).some((constituent) => isFalsyLiteralType(constituent) || constituent.getFlags() & (ts.TypeFlags.String | ts.TypeFlags.Number | ts.TypeFlags.BigInt | ts.TypeFlags.Boolean));
-}
-var nullishCoalescingOperators_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Prefer nullish coalescing operator (??) over logical OR (||) for nullish values.",
-		id: "nullishCoalescingOperators",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: {
-		preferNullish: {
-			primary: "Prefer nullish coalescing operator (`??`) over logical OR (`||`) for nullish checks.",
-			secondary: ["The `||` operator returns the right operand for any falsy value (empty string, 0, false, null, undefined).", "The `??` operator only returns the right operand for null or undefined, preserving other falsy values."],
-			suggestions: ["Replace `||` with `??`."]
-		},
-		preferNullishAssignment: {
-			primary: "Prefer nullish coalescing assignment (`??=`) over assignment with null/undefined check.",
-			secondary: [],
-			suggestions: ["Replace with nullish coalescing assignment."]
-		},
-		preferNullishTernary: {
-			primary: "Prefer nullish coalescing operator (`??`) over ternary expression for nullish checks.",
-			secondary: [],
-			suggestions: ["Replace with nullish coalescing."]
-		}
-	},
-	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([
-			"bigint",
-			"boolean",
-			"number",
-			"string"
-		]), z.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.")
-	},
-	setup(context) {
-		function getOptionalChainInsertPosition(node, test, sourceFile) {
-			if (node.kind === ts.SyntaxKind.PropertyAccessExpression || node.kind === ts.SyntaxKind.ElementAccessExpression) {
-				if (hasSameTokens(node.expression, test, sourceFile)) return {
-					needsDot: ts.isElementAccessExpression(node),
-					pos: node.expression.getEnd()
-				};
-				return getOptionalChainInsertPosition(node.expression, test, sourceFile);
-			}
-			if (ts.isCallExpression(node)) return getOptionalChainInsertPosition(node.expression, test, sourceFile);
-		}
-		function createNullishNodesFix(consequent, alternate, sourceFile, range, test) {
-			const getText = (node) => sourceFile.text.substring(node.getStart(sourceFile), node.getEnd());
-			let leftText = getText(consequent);
-			if (test && test !== consequent) {
-				const insert = getOptionalChainInsertPosition(consequent, test, sourceFile);
-				if (insert) {
-					const offset = insert.pos - consequent.getStart(sourceFile);
-					leftText = leftText.slice(0, offset) + (insert.needsDot ? "?." : "?") + leftText.slice(offset);
-				}
-			}
-			return {
-				range,
-				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;
-				const range = getTSNodeRange(node.operatorToken, sourceFile);
-				const fullRange = getTSNodeRange(node, sourceFile);
-				context.report({
-					fix: {
-						range,
-						text: node.operatorToken.kind === ts.SyntaxKind.BarBarToken ? "??" : "??="
-					},
-					message: "preferNullish",
-					range: fullRange
-				});
-			},
-			ConditionalExpression: (node, { options, sourceFile, typeChecker }) => {
-				if (options.ignoreTernaryTests || options.ignoreConditionalTests && isConditionalTest(node)) return;
-				const { alternate, consequent, test } = analyzeConditionalForNullish(node, sourceFile);
-				if (!test || !consequent || !alternate || shouldIgnoreNode(test, options.ignorePrimitives, typeChecker)) return;
-				const range = getTSNodeRange(node, sourceFile);
-				context.report({
-					fix: createNullishNodesFix(consequent, alternate, sourceFile, range, test),
-					message: "preferNullishTernary",
-					range
-				});
-			},
-			IfStatement: (node, { options, sourceFile, typeChecker }) => {
-				const checkedValue = getIfStatementNullishCheckValue(node);
-				if (options.ignoreIfStatements || node.elseStatement || !checkedValue) return;
-				const assignmentExpression = extractAssignmentFromIfStatement(node);
-				if (!assignmentExpression || !hasSameTokens(assignmentExpression.left, checkedValue, sourceFile) || shouldIgnoreNode(assignmentExpression.left, options.ignorePrimitives, typeChecker)) return;
-				const range = getTSNodeRange(node, sourceFile);
-				context.report({
-					fix: createNullishAssignmentFix(assignmentExpression.left, assignmentExpression.right, sourceFile, range),
-					message: "preferNullishAssignment",
-					range
-				});
-			}
-		} };
-	}
-});
-//#endregion
-export { nullishCoalescingOperators_default as default };
-
-//# sourceMappingURL=nullishCoalescingOperators.js.map

package/lib/rules/numberMethodRanges.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports when number method arguments are outside their valid range.";
-    readonly id: "numberMethodRanges";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "outOfRange", undefined>;
-export default _default;
-//# sourceMappingURL=numberMethodRanges.d.ts.map