@flint.fyi/ts 0.15.0 → 0.18.1

package/lib/rules/newNativeNonConstructors.js

@@ -1,50 +1,39 @@
-import * as ts from "typescript";
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
-import { isGlobalDeclaration } from "../utils/isGlobalDeclaration.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Disallows using `new` with global non-constructor functions like Symbol and BigInt.",
-        id: "newNativeNonConstructors",
-        preset: "untyped",
-    },
-    messages: {
-        noNewNonConstructor: {
-            primary: "{{ name }} cannot be called with `new`.",
-            secondary: [
-                "`Symbol` and `BigInt` are not constructors and will throw a `TypeError` when called with `new`.",
-                "These functions should be called directly without the `new` keyword to create their respective values.",
-            ],
-            suggestions: ["Remove the `new` keyword and call the function directly."],
-        },
-    },
-    setup(context) {
-        return {
-            visitors: {
-                NewExpression: (node, { sourceFile, typeChecker }) => {
-                    if (!ts.isIdentifier(node.expression)) {
-                        return;
-                    }
-                    const name = node.expression.text;
-                    if (!["BigInt", "Symbol"].includes(name) ||
-                        !isGlobalDeclaration(node.expression, typeChecker)) {
-                        return;
-                    }
-                    context.report({
-                        data: { name },
-                        fix: {
-                            range: {
-                                begin: node.getStart(sourceFile),
-                                end: node.expression.getStart(sourceFile),
-                            },
-                            text: "",
-                        },
-                        message: "noNewNonConstructor",
-                        range: getTSNodeRange(node.getChildAt(0, sourceFile), sourceFile),
-                    });
-                },
-            },
-        };
-    },
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, isGlobalDeclaration, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/newNativeNonConstructors.ts
+var newNativeNonConstructors_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Disallows using `new` with global non-constructor functions like Symbol and BigInt.",
+		id: "newNativeNonConstructors",
+		presets: ["javascript"]
+	},
+	messages: { noNewNonConstructor: {
+		primary: "{{ name }} cannot be called with `new`.",
+		secondary: ["`Symbol` and `BigInt` are not constructors and will throw a `TypeError` when called with `new`.", "These functions should be called directly without the `new` keyword to create their respective values."],
+		suggestions: ["Remove the `new` keyword and call the function directly."]
+	} },
+	setup(context) {
+		return { visitors: { NewExpression: (node, { sourceFile, typeChecker }) => {
+			if (node.expression.kind !== SyntaxKind.Identifier) return;
+			const name = node.expression.text;
+			if (!["BigInt", "Symbol"].includes(name) || !isGlobalDeclaration(node.expression, typeChecker)) return;
+			context.report({
+				data: { name },
+				fix: {
+					range: {
+						begin: node.getStart(sourceFile),
+						end: node.expression.getStart(sourceFile)
+					},
+					text: ""
+				},
+				message: "noNewNonConstructor",
+				range: getTSNodeRange(node.getChildAt(0, sourceFile), sourceFile)
+			});
+		} } };
+	}
 });
+//#endregion
+export { newNativeNonConstructors_default as default };
+
 //# sourceMappingURL=newNativeNonConstructors.js.map

package/lib/rules/nonNullAssertedNullishCoalesces.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports non-null assertions on the left side of nullish coalescing operators.";
+    readonly id: "nonNullAssertedNullishCoalesces";
+    readonly presets: ["logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unnecessaryNonNullAssertion", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=nonNullAssertedNullishCoalesces.d.ts.map

package/lib/rules/nonNullAssertedNullishCoalesces.js

@@ -0,0 +1,63 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+import * as tsutils from "ts-api-utils";
+//#region src/rules/nonNullAssertedNullishCoalesces.ts
+function hasNoAssignmentBeforeNode(identifier, node, sourceFile, typeChecker) {
+	const symbol = typeChecker.getSymbolAtLocation(identifier);
+	if (!symbol) return false;
+	const declarations = symbol.getDeclarations();
+	if (!declarations?.length) return false;
+	const nodeEnd = node.getEnd();
+	for (const declaration of declarations) {
+		if (declaration.getEnd() >= nodeEnd) continue;
+		if (ts$1.isVariableDeclaration(declaration)) {
+			if (declaration.exclamationToken || declaration.initializer) return false;
+		} else if (ts$1.isParameter(declaration) && declaration.initializer) return false;
+	}
+	const valueDeclaration = symbol.valueDeclaration;
+	if (!valueDeclaration) return true;
+	function findModifyingReference(current) {
+		if (ts$1.isIdentifier(current)) {
+			if (typeChecker.getSymbolAtLocation(current)?.valueDeclaration === valueDeclaration) {
+				const parent = current.parent;
+				if (ts$1.isBinaryExpression(parent) && tsutils.isAssignmentKind(parent.operatorToken.kind) && parent.left === current && parent.getEnd() < nodeEnd) return true;
+				if ((ts$1.isPostfixUnaryExpression(parent) || ts$1.isPrefixUnaryExpression(parent)) && parent.operand === current && parent.getEnd() < nodeEnd) return true;
+			}
+		}
+		return ts$1.forEachChild(current, findModifyingReference) ?? false;
+	}
+	return !findModifyingReference(sourceFile);
+}
+var nonNullAssertedNullishCoalesces_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports non-null assertions on the left side of nullish coalescing operators.",
+		id: "nonNullAssertedNullishCoalesces",
+		presets: ["logicalStrict"]
+	},
+	messages: { unnecessaryNonNullAssertion: {
+		primary: "The nullish coalescing operator handles null and undefined, making this non-null assertion redundant.",
+		secondary: ["The `??` operator returns its right operand when the left operand is null or undefined.", "Applying `!` to assert the value is non-null defeats the purpose of using `??`."],
+		suggestions: ["Remove the non-null assertion."]
+	} },
+	setup(context) {
+		return { visitors: { NonNullExpression: (node, { sourceFile, typeChecker }) => {
+			if (node.parent.kind !== ts$1.SyntaxKind.BinaryExpression || node.parent.operatorToken.kind !== ts$1.SyntaxKind.QuestionQuestionToken || node.parent.left !== node) return;
+			if (node.expression.kind === ts$1.SyntaxKind.Identifier && hasNoAssignmentBeforeNode(node.expression, node, sourceFile, typeChecker)) return;
+			const range = getTSNodeRange(node, sourceFile);
+			context.report({
+				message: "unnecessaryNonNullAssertion",
+				range,
+				suggestions: [{
+					id: "removeNonNullAssertion",
+					range,
+					text: node.expression.getText(sourceFile)
+				}]
+			});
+		} } };
+	}
+});
+//#endregion
+export { nonNullAssertedNullishCoalesces_default as default };
+
+//# sourceMappingURL=nonNullAssertedNullishCoalesces.js.map

package/lib/rules/nonNullAssertedOptionalChains.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports non-null assertions on optional chain expressions.";
+    readonly id: "nonNullAssertedOptionalChains";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "nonNullOptionalChain", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=nonNullAssertedOptionalChains.d.ts.map

package/lib/rules/nonNullAssertedOptionalChains.js

@@ -0,0 +1,69 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/nonNullAssertedOptionalChains.ts
+function containsOptionalChain(node) {
+	let current = node;
+	let foundNonOptionalAccess = false;
+	while (true) {
+		if (ts$1.isParenthesizedExpression(current)) return !foundNonOptionalAccess && isOptionalChainRoot(current.expression);
+		if (ts$1.isNonNullExpression(current)) {
+			current = current.expression;
+			continue;
+		}
+		if (ts$1.isPropertyAccessExpression(current) || ts$1.isElementAccessExpression(current) || ts$1.isCallExpression(current)) {
+			if (current.questionDotToken) return true;
+			foundNonOptionalAccess = true;
+			current = current.expression;
+			continue;
+		}
+		return false;
+	}
+}
+function isNonNullExpressionContinued(node) {
+	if (ts$1.isParenthesizedExpression(node.expression)) return false;
+	if (ts$1.isPropertyAccessExpression(node.parent) || ts$1.isElementAccessExpression(node.parent) || ts$1.isCallExpression(node.parent)) return node.parent.expression === node;
+	return false;
+}
+function isOptionalChainRoot(node) {
+	let current = node;
+	while (true) {
+		if (ts$1.isNonNullExpression(current) || ts$1.isParenthesizedExpression(current)) {
+			current = current.expression;
+			continue;
+		}
+		if (ts$1.isPropertyAccessExpression(current) || ts$1.isElementAccessExpression(current) || ts$1.isCallExpression(current)) return Boolean(current.questionDotToken);
+		return false;
+	}
+}
+var nonNullAssertedOptionalChains_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports non-null assertions on optional chain expressions.",
+		id: "nonNullAssertedOptionalChains",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { nonNullOptionalChain: {
+		primary: "Non-null assertions are unsafe on optional chain expressions because they can still return undefined.",
+		secondary: ["Optional chain expressions (`?.`) return `undefined` when the left side is `null` or `undefined`.", "Applying a non-null assertion (`!`) doesn't change the runtime behavior and can mask potential bugs."],
+		suggestions: ["Remove the non-null assertion."]
+	} },
+	setup(context) {
+		return { visitors: { NonNullExpression: (node, { sourceFile }) => {
+			if (!containsOptionalChain(node.expression) || isNonNullExpressionContinued(node)) return;
+			const range = getTSNodeRange(node, sourceFile);
+			context.report({
+				message: "nonNullOptionalChain",
+				range,
+				suggestions: [{
+					id: "removeNonNullAssertion",
+					range,
+					text: node.expression.getText(sourceFile)
+				}]
+			});
+		} } };
+	}
+});
+//#endregion
+export { nonNullAssertedOptionalChains_default as default };
+
+//# sourceMappingURL=nonNullAssertedOptionalChains.js.map

package/lib/rules/nonNullAssertionPlacement.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports confusing placement of non-null assertions next to comparison or assignment operators.";
+    readonly id: "nonNullAssertionPlacement";
+    readonly presets: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "confusingAssign" | "confusingEqual" | "confusingOperator", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=nonNullAssertionPlacement.d.ts.map

package/lib/rules/nonNullAssertionPlacement.js

@@ -0,0 +1,94 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/nonNullAssertionPlacement.ts
+function endsWithNonNullAssertion(node, sourceFile) {
+	return node.getLastToken(sourceFile)?.kind === SyntaxKind.ExclamationToken;
+}
+const confusingOperatorTexts = new Map([
+	[SyntaxKind.EqualsEqualsEqualsToken, "==="],
+	[SyntaxKind.EqualsEqualsToken, "=="],
+	[SyntaxKind.EqualsToken, "="],
+	[SyntaxKind.InKeyword, "in"],
+	[SyntaxKind.InstanceOfKeyword, "instanceof"]
+]);
+var nonNullAssertionPlacement_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports confusing placement of non-null assertions next to comparison or assignment operators.",
+		id: "nonNullAssertionPlacement",
+		presets: ["stylisticStrict"]
+	},
+	messages: {
+		confusingAssign: {
+			primary: "Non-null assertion before assignment (`a! = b`) looks similar to not-equals (`a != b`).",
+			secondary: ["This placement creates visual confusion between the assignment `=` and the not-equals operator `!=`.", "Moving the non-null assertion or wrapping the left side in parentheses makes the intent clearer."],
+			suggestions: ["Remove the non-null assertion if it's unnecessary.", "Wrap the left-hand side in parentheses to clarify intent."]
+		},
+		confusingEqual: {
+			primary: "Non-null assertion before equality test (`a! == b`) looks similar to strict not-equals (`a !== b`).",
+			secondary: ["This placement creates visual confusion between the equality operators and the not-equals operators.", "Moving the non-null assertion or wrapping the left side in parentheses makes the intent clearer."],
+			suggestions: ["Remove the non-null assertion if it's unnecessary.", "Wrap the left-hand side in parentheses to clarify intent."]
+		},
+		confusingOperator: {
+			primary: "Non-null assertion before `{{ operator }}` operator (`a! {{ operator }} b`) might be misread as `!(a {{ operator }} b)`.",
+			secondary: ["This placement creates visual confusion that could suggest the entire expression is being negated.", "Moving the non-null assertion or wrapping the left side in parentheses makes the intent clearer."],
+			suggestions: ["Remove the non-null assertion if it's unnecessary.", "Wrap the left-hand side in parentheses to clarify intent."]
+		}
+	},
+	setup(context) {
+		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
+			const operatorText = confusingOperatorTexts.get(node.operatorToken.kind);
+			if (!operatorText || !endsWithNonNullAssertion(node.left, sourceFile)) return;
+			const range = {
+				begin: node.left.end - 1,
+				end: node.left.end
+			};
+			const leftText = node.left.getText(sourceFile);
+			const innerExpression = node.left.kind === SyntaxKind.NonNullExpression && node.left.expression;
+			const suggestions = [...innerExpression ? [{
+				id: "removeAssertion",
+				range: {
+					begin: node.left.getStart(sourceFile),
+					end: node.left.end
+				},
+				text: innerExpression.getText(sourceFile)
+			}] : [], {
+				id: "wrapInParentheses",
+				range: {
+					begin: node.left.getStart(sourceFile),
+					end: node.left.end
+				},
+				text: `(${leftText})`
+			}];
+			switch (node.operatorToken.kind) {
+				case SyntaxKind.EqualsToken:
+					context.report({
+						message: "confusingAssign",
+						range,
+						suggestions
+					});
+					break;
+				case SyntaxKind.InKeyword:
+				case SyntaxKind.InstanceOfKeyword:
+					context.report({
+						data: { operator: operatorText },
+						message: "confusingOperator",
+						range,
+						suggestions
+					});
+					break;
+				default:
+					context.report({
+						message: "confusingEqual",
+						range,
+						suggestions
+					});
+					break;
+			}
+		} } };
+	}
+});
+//#endregion
+export { nonNullAssertionPlacement_default as default };
+
+//# sourceMappingURL=nonNullAssertionPlacement.js.map

package/lib/rules/nonNullableTypeAssertions.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports type assertions that can be replaced with non-null assertions.";
+    readonly id: "nonNullableTypeAssertions";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferNonNullAssertion", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=nonNullableTypeAssertions.d.ts.map

package/lib/rules/nonNullableTypeAssertions.js

@@ -0,0 +1,78 @@
+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,8 +1,10 @@
-import { TypeScriptFileServices } from "../language.js";
 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 preset: "logical";
-}, import("../nodes.js").TSNodesByName, TypeScriptFileServices, "unexpectedEscape", undefined>;
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unexpectedEscape", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
 //# sourceMappingURL=nonOctalDecimalEscapes.d.ts.map

package/lib/rules/nonOctalDecimalEscapes.js

@@ -1,58 +1,48 @@
-import { typescriptLanguage } from "../language.js";
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+//#region src/rules/nonOctalDecimalEscapes.ts
 const nonOctalDecimalEscapePattern = /\\[89]/g;
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports non-octal decimal escape sequences (\\8 and \\9) in string literals.",
-        id: "nonOctalDecimalEscapes",
-        preset: "logical",
-    },
-    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) {
-                // Ignore escapes where the backslash itself is escaped (e.g. "\\\\8" -> literal "\\8").
-                // Count the number of consecutive backslashes immediately before the match.
-                const matchIndex = match.index;
-                let backslashesBefore = 0;
-                for (let i = matchIndex - 1; i >= 0 && text[i] === "\\"; i--) {
-                    backslashesBefore++;
-                }
-                // If there is an odd number of backslashes before this one, the backslash is escaped
-                // and should not be treated as an escape sequence.
-                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,
-            },
-        };
-    },
+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

@@ -0,0 +1,21 @@
+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";
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferLooseNull" | "preferLooseNullish" | "preferLooseUndefined" | "preferStrictNullish", {
+    readonly looseNullishComparisonStyle: z.ZodDefault<z.ZodEnum<{
+        "prefer-null": "prefer-null";
+        "prefer-undefined": "prefer-undefined";
+        ignore: "ignore";
+    }>>;
+    readonly nullishComparisonStrictness: z.ZodDefault<z.ZodEnum<{
+        ignore: "ignore";
+        "double-equals": "double-equals";
+        "triple-equals": "triple-equals";
+    }>>;
+}>;
+export default _default;
+//# sourceMappingURL=nullishCheckStyle.d.ts.map