@flint.fyi/ts 0.14.6 → 0.18.0

package/lib/rules/errorSubclassProperties.js

@@ -0,0 +1,144 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { isErrorSubclass } from "./utils/isErrorSubclass.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts, { SyntaxKind } from "typescript";
+//#region src/rules/errorSubclassProperties.ts
+function analyzeConstructor(node) {
+	let constructor;
+	for (const member of node.members) if (ts.isConstructorDeclaration(member) && member.body) {
+		constructor = member;
+		break;
+	}
+	if (!constructor) return;
+	let hasSuperCall = false;
+	let superCallPassesMessage = false;
+	let hasNameAssignment = false;
+	let nameValue;
+	let hasRedundantMessageAssignment = false;
+	let superCallNode;
+	let nameAssignmentNode;
+	let messageAssignmentNode;
+	const body = constructor.body;
+	if (!body) return;
+	for (const statement of body.statements) {
+		if (!ts.isExpressionStatement(statement)) continue;
+		if (ts.isCallExpression(statement.expression) && statement.expression.expression.kind === SyntaxKind.SuperKeyword) {
+			hasSuperCall = true;
+			superCallNode = statement.expression;
+			superCallPassesMessage = !!statement.expression.arguments.length;
+		}
+		if (ts.isBinaryExpression(statement.expression) && statement.expression.operatorToken.kind === SyntaxKind.EqualsToken && ts.isPropertyAccessExpression(statement.expression.left) && statement.expression.left.expression.kind === SyntaxKind.ThisKeyword) {
+			const propName = statement.expression.left.name.text;
+			if (propName === "name") {
+				hasNameAssignment = true;
+				nameAssignmentNode = statement.expression;
+				if (ts.isStringLiteral(statement.expression.right)) nameValue = statement.expression.right.text;
+				else if (ts.isPropertyAccessExpression(statement.expression.right) && ts.isPropertyAccessExpression(statement.expression.right.expression) && statement.expression.right.expression.expression.kind === SyntaxKind.ThisKeyword && statement.expression.right.expression.name.text === "constructor" && statement.expression.right.name.text === "name") nameValue = "this.constructor.name";
+			}
+			if (propName === "message" && hasSuperCall && superCallPassesMessage) {
+				hasRedundantMessageAssignment = true;
+				messageAssignmentNode = statement.expression;
+			}
+		}
+	}
+	return {
+		constructor,
+		hasNameAssignment,
+		hasRedundantMessageAssignment,
+		hasSuperCall,
+		messageAssignmentNode,
+		nameAssignmentNode,
+		nameValue,
+		superCallNode,
+		superCallPassesMessage
+	};
+}
+function isValidErrorClassName(name) {
+	return !!name && /^[A-Z]/.test(name) && name.endsWith("Error");
+}
+var errorSubclassProperties_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports incorrect Error subclass definitions that don't follow best practices.",
+		id: "errorSubclassProperties",
+		presets: ["logicalStrict"]
+	},
+	messages: {
+		invalidClassName: {
+			primary: "Error subclass name '{{ name }}' should start with an uppercase letter and end with 'Error'.",
+			secondary: ["Error class names should follow the convention of being capitalized and ending with 'Error'.", "This makes it clear that the class is an error type."],
+			suggestions: ["Rename the class to end with 'Error', e.g., '{{ suggested }}'."]
+		},
+		missingName: {
+			primary: "Error subclass is missing a `this.name` assignment in the constructor.",
+			secondary: ["Without a `name` property, errors will display as `[Error: ...]` instead of `[ClassName: ...]`.", "Setting `this.name` helps identify the error type when debugging."],
+			suggestions: ["Add `this.name = 'ClassName';` to the constructor."]
+		},
+		redundantMessage: {
+			primary: "Assignment to `this.message` is redundant when the message is already passed to `super()`.",
+			secondary: ["The `super()` call automatically sets the `message` property.", "Assigning it again is unnecessary."],
+			suggestions: ["Remove the redundant `this.message` assignment."]
+		},
+		useConstructorName: {
+			primary: "Avoid using `this.constructor.name` for the error name.",
+			secondary: ["Using `this.constructor.name` will not work correctly after minification.", "Use a string literal instead to ensure the error name is preserved."],
+			suggestions: ["Use a string literal like `this.name = '{{ className }}';`."]
+		},
+		wrongName: {
+			primary: "Error subclass name property '{{ nameValue }}' should match the class name '{{ className }}'.",
+			secondary: ["The `name` property should match the class name for consistency.", "Mismatched names can cause confusion when debugging."],
+			suggestions: ["Change the name assignment to `this.name = '{{ className }}';`."]
+		}
+	},
+	setup(context) {
+		return { visitors: { ClassDeclaration: (node, { sourceFile, typeChecker }) => {
+			if (!isErrorSubclass(node, typeChecker)) return;
+			const className = node.name?.text;
+			if (!isValidErrorClassName(className)) {
+				const baseName = className ?? "Custom";
+				const suggested = baseName.endsWith("Error") ? baseName : `${baseName}Error`;
+				context.report({
+					data: {
+						name: className ?? "(anonymous)",
+						suggested
+					},
+					message: "invalidClassName",
+					range: getTSNodeRange(node.name ?? node, sourceFile)
+				});
+				return;
+			}
+			const constructorInfo = analyzeConstructor(node);
+			if (!constructorInfo) return;
+			if (constructorInfo.hasRedundantMessageAssignment && constructorInfo.messageAssignmentNode) context.report({
+				message: "redundantMessage",
+				range: getTSNodeRange(constructorInfo.messageAssignmentNode, sourceFile)
+			});
+			if (!constructorInfo.hasNameAssignment) {
+				context.report({
+					message: "missingName",
+					range: getTSNodeRange(constructorInfo.constructor, sourceFile)
+				});
+				return;
+			}
+			if (constructorInfo.nameValue === "this.constructor.name" && constructorInfo.nameAssignmentNode) {
+				context.report({
+					data: { className },
+					message: "useConstructorName",
+					range: getTSNodeRange(constructorInfo.nameAssignmentNode, sourceFile)
+				});
+				return;
+			}
+			if (constructorInfo.nameValue && constructorInfo.nameValue !== className && constructorInfo.nameAssignmentNode) context.report({
+				data: {
+					className,
+					nameValue: constructorInfo.nameValue
+				},
+				message: "wrongName",
+				range: getTSNodeRange(constructorInfo.nameAssignmentNode, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+export { errorSubclassProperties_default as default };
+
+//# sourceMappingURL=errorSubclassProperties.js.map

package/lib/rules/errorUnnecessaryCaptureStackTraces.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports unnecessary Error.captureStackTrace() calls in Error subclass constructors.";
+    readonly id: "errorUnnecessaryCaptureStackTraces";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unnecessaryCaptureStackTrace", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=errorUnnecessaryCaptureStackTraces.d.ts.map

package/lib/rules/errorUnnecessaryCaptureStackTraces.js

@@ -0,0 +1,55 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { isErrorSubclass } from "./utils/isErrorSubclass.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts, { SyntaxKind } from "typescript";
+//#region src/rules/errorUnnecessaryCaptureStackTraces.ts
+function isCaptureStackTraceCall(node) {
+	if (!ts.isCallExpression(node) && !ts.isOptionalChain(node)) return false;
+	const callExpression = ts.isCallExpression(node) ? node : void 0;
+	if (!callExpression) return ts.isCallExpression(node) && isCaptureStackTraceCall(node);
+	return ts.isPropertyAccessExpression(callExpression.expression) && ts.isIdentifier(callExpression.expression.expression) && callExpression.expression.expression.text === "Error" && ts.isIdentifier(callExpression.expression.name) && callExpression.expression.name.text === "captureStackTrace";
+}
+function isValidSecondArgument(node, className) {
+	if (ts.isIdentifier(node)) return node.text === className;
+	if (ts.isPropertyAccessExpression(node) && node.expression.kind === SyntaxKind.ThisKeyword && ts.isIdentifier(node.name) && node.name.text === "constructor") return true;
+	if (ts.isMetaProperty(node) && node.keywordToken === SyntaxKind.NewKeyword && ts.isIdentifier(node.name) && node.name.text === "target") return true;
+	return false;
+}
+var errorUnnecessaryCaptureStackTraces_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports unnecessary Error.captureStackTrace() calls in Error subclass constructors.",
+		id: "errorUnnecessaryCaptureStackTraces",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { unnecessaryCaptureStackTrace: {
+		primary: "Calling `Error.captureStackTrace()` is unnecessary in built-in Error subclass constructors.",
+		secondary: ["The `Error` constructor automatically calls `Error.captureStackTrace()` when extending built-in Error types.", "Calling it again is redundant and adds unnecessary code."],
+		suggestions: ["Remove the `Error.captureStackTrace()` call."]
+	} },
+	setup(context) {
+		return { visitors: { ClassDeclaration: (node, { sourceFile, typeChecker }) => {
+			if (!isErrorSubclass(node, typeChecker)) return;
+			for (const member of node.members) {
+				if (!ts.isConstructorDeclaration(member) || !member.body) continue;
+				for (const statement of member.body.statements) {
+					if (!ts.isExpressionStatement(statement) || !(ts.isCallExpression(statement.expression) || ts.isCallChain(statement.expression)) || !isCaptureStackTraceCall(statement.expression)) continue;
+					const args = statement.expression.arguments;
+					if (args.length < 1) continue;
+					if (args[0].kind !== SyntaxKind.ThisKeyword) continue;
+					if (args.length >= 2) {
+						const secondArgument = args[1];
+						if (!isValidSecondArgument(secondArgument, node.name?.text)) continue;
+					}
+					context.report({
+						message: "unnecessaryCaptureStackTrace",
+						range: getTSNodeRange(statement, sourceFile)
+					});
+				}
+			}
+		} } };
+	}
+});
+//#endregion
+export { errorUnnecessaryCaptureStackTraces_default as default };
+
+//# sourceMappingURL=errorUnnecessaryCaptureStackTraces.js.map

package/lib/rules/escapeSequenceCasing.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports escape sequences with lowercase hexadecimal characters.";
+    readonly id: "escapeSequenceCasing";
+    readonly presets: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "useUppercase", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=escapeSequenceCasing.d.ts.map

package/lib/rules/escapeSequenceCasing.js

@@ -0,0 +1,75 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+//#region src/rules/escapeSequenceCasing.ts
+const escapeCase = /(?<=(?:^|[^\\])(?:\\\\)*\\)(?:x[\dA-Fa-f]{2}|u[\dA-Fa-f]{4}|u\{[\dA-Fa-f]+\}|c[a-z])/g;
+function findLowercaseEscapeSequence(text) {
+	for (const pattern of [
+		/\\x([0-9a-f]{2})/g,
+		/\\u([0-9a-f]{4})/g,
+		/\\u\{([0-9a-f]+)\}/g,
+		/\\c([a-z])/g
+	]) {
+		let match;
+		while ((match = pattern.exec(text)) !== null) {
+			const hexPart = match[1];
+			if (hexPart && hexPart !== hexPart.toUpperCase()) {
+				const original = match[0];
+				return {
+					fixed: original.replace(escapeCase, (data) => data[0] + data.slice(1).toUpperCase()),
+					index: match.index,
+					length: original.length,
+					original
+				};
+			}
+		}
+	}
+}
+var escapeSequenceCasing_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports escape sequences with lowercase hexadecimal characters.",
+		id: "escapeSequenceCasing",
+		presets: ["stylisticStrict"]
+	},
+	messages: { useUppercase: {
+		primary: "Prefer uppercase characters for escape sequence '{{ original }}'.",
+		secondary: ["Uppercase hexadecimal characters in escape sequences are more readable and distinguishable from identifiers."],
+		suggestions: ["Change '{{ original }}' to '{{ fixed }}'."]
+	} },
+	setup(context) {
+		function checkNode(node, { sourceFile }) {
+			const escapeInfo = findLowercaseEscapeSequence(node.getText(sourceFile));
+			if (!escapeInfo) return;
+			const nodeStart = node.getStart(sourceFile);
+			context.report({
+				data: {
+					fixed: escapeInfo.fixed,
+					original: escapeInfo.original
+				},
+				fix: {
+					range: {
+						begin: nodeStart + escapeInfo.index,
+						end: nodeStart + escapeInfo.index + escapeInfo.length
+					},
+					text: escapeInfo.fixed
+				},
+				message: "useUppercase",
+				range: {
+					begin: nodeStart + escapeInfo.index,
+					end: nodeStart + escapeInfo.index + escapeInfo.length
+				}
+			});
+		}
+		return { visitors: {
+			NoSubstitutionTemplateLiteral: checkNode,
+			StringLiteral: checkNode,
+			TemplateExpression: (node, services) => {
+				checkNode(node.head, services);
+				for (const span of node.templateSpans) checkNode(span.literal, services);
+			}
+		} };
+	}
+});
+//#endregion
+export { escapeSequenceCasing_default as default };
+
+//# sourceMappingURL=escapeSequenceCasing.js.map

package/lib/rules/evals.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports uses of the eval function.";
+    readonly id: "evals";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "noEval", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=evals.d.ts.map

package/lib/rules/evals.js

@@ -0,0 +1,31 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
+//#region src/rules/evals.ts
+var evals_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports uses of the eval function.",
+		id: "evals",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { noEval: {
+		primary: "Avoid using `eval()` as it poses security and performance risks.",
+		secondary: [
+			"`eval()` executes arbitrary code, which can be exploited for code injection attacks.",
+			"It prevents JavaScript engine optimizations, making code run slower.",
+			"It makes code harder to debug and reason about."
+		],
+		suggestions: ["Use safer alternatives like `JSON.parse()` for parsing JSON data.", "Use `Function` constructor if dynamic code execution is truly necessary (though still risky)."]
+	} },
+	setup(context) {
+		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
+			if (isGlobalDeclarationOfName(node.expression, "eval", typeChecker)) context.report({
+				message: "noEval",
+				range: getTSNodeRange(node.expression, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+export { evals_default as default };
+
+//# sourceMappingURL=evals.js.map

package/lib/rules/evolvingVariableTypes.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports variables declared without type annotation or initializer.";
+    readonly id: "evolvingVariableTypes";
+    readonly presets: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "implicitAny", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=evolvingVariableTypes.d.ts.map

package/lib/rules/evolvingVariableTypes.js

@@ -0,0 +1,33 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts, { SyntaxKind } from "typescript";
+//#region src/rules/evolvingVariableTypes.ts
+var evolvingVariableTypes_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports variables declared without type annotation or initializer.",
+		id: "evolvingVariableTypes",
+		presets: ["stylisticStrict"]
+	},
+	messages: { implicitAny: {
+		primary: "Variable '{{ name }}' has an implicit evolving 'any' type due to missing type annotation and initializer.",
+		secondary: ["Variables declared without a type annotation or initial value implicitly have the 'any' type.", "This allows any type of value to be assigned to the variable, which can make it harder to catch type-related bugs at compile time."],
+		suggestions: ["Add a type annotation to the variable declaration.", "Initialize the variable with a value so TypeScript can infer its type."]
+	} },
+	setup(context) {
+		return { visitors: { VariableDeclaration: (node, { sourceFile }) => {
+			if (sourceFile.isDeclarationFile || node.initializer !== void 0 || node.type !== void 0 || node.name.kind !== SyntaxKind.Identifier || node.parent.kind === SyntaxKind.CatchClause || node.parent.flags & ts.NodeFlags.Const || node.parent.parent.kind === SyntaxKind.ForInStatement || node.parent.parent.kind === SyntaxKind.ForOfStatement) return;
+			context.report({
+				data: { name: node.name.text },
+				message: "implicitAny",
+				range: {
+					begin: node.name.getStart(sourceFile),
+					end: node.name.getEnd()
+				}
+			});
+		} } };
+	}
+});
+//#endregion
+export { evolvingVariableTypes_default as default };
+
+//# sourceMappingURL=evolvingVariableTypes.js.map

package/lib/rules/exceptionAssignments.d.ts

@@ -1,6 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports reassigning exception parameters in catch clauses.";
     readonly id: "exceptionAssignments";
-    readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noExAssign", undefined>;
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "noExAssign", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
+//# sourceMappingURL=exceptionAssignments.d.ts.map

package/lib/rules/exceptionAssignments.js

@@ -1,61 +1,42 @@
-import * as ts from "typescript";
-import { typescriptLanguage } from "../language.js";
-import { getModifyingReferences } from "../utils/getModifyingReferences.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports reassigning exception parameters in catch clauses.",
-        id: "exceptionAssignments",
-        preset: "logical",
-    },
-    messages: {
-        noExAssign: {
-            primary: "Exception parameters in catch clauses should not be reassigned.",
-            secondary: [
-                "Reassigning an exception parameter can make debugging more difficult by obscuring the original error.",
-                "The exception parameter contains important information about what went wrong, and reassigning it can make it harder to understand the root cause of an error.",
-            ],
-            suggestions: [
-                "Use a different variable name for the new value instead of reassigning the exception parameter.",
-            ],
-        },
-    },
-    setup(context) {
-        function collectBindingElements(name) {
-            const identifiers = [];
-            if (ts.isIdentifier(name)) {
-                identifiers.push(name);
-            }
-            else if (ts.isObjectBindingPattern(name) ||
-                ts.isArrayBindingPattern(name)) {
-                for (const element of name.elements) {
-                    if (ts.isBindingElement(element)) {
-                        identifiers.push(...collectBindingElements(element.name));
-                    }
-                }
-            }
-            return identifiers;
-        }
-        return {
-            visitors: {
-                CatchClause: (node) => {
-                    if (!node.variableDeclaration?.name) {
-                        return;
-                    }
-                    const identifiers = collectBindingElements(node.variableDeclaration.name);
-                    for (const identifier of identifiers) {
-                        const modifyingReferences = getModifyingReferences(identifier, context.sourceFile, context.typeChecker);
-                        for (const reference of modifyingReferences) {
-                            context.report({
-                                message: "noExAssign",
-                                range: {
-                                    begin: reference.getStart(context.sourceFile),
-                                    end: reference.getEnd(),
-                                },
-                            });
-                        }
-                    }
-                },
-            },
-        };
-    },
+import { ruleCreator } from "./ruleCreator.js";
+import { getModifyingReferences, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/exceptionAssignments.ts
+var exceptionAssignments_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports reassigning exception parameters in catch clauses.",
+		id: "exceptionAssignments",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { noExAssign: {
+		primary: "Exception parameters in catch clauses should not be reassigned.",
+		secondary: ["Reassigning an exception parameter can make debugging more difficult by obscuring the original error.", "The exception parameter contains important information about what went wrong, and reassigning it can make it harder to understand the root cause of an error."],
+		suggestions: ["Use a different variable name for the new value instead of reassigning the exception parameter."]
+	} },
+	setup(context) {
+		function collectBindingElements(name) {
+			const identifiers = [];
+			if (name.kind === SyntaxKind.Identifier) identifiers.push(name);
+			else for (const element of name.elements) if (element.kind === SyntaxKind.BindingElement) identifiers.push(...collectBindingElements(element.name));
+			return identifiers;
+		}
+		return { visitors: { CatchClause: (node, { sourceFile, typeChecker }) => {
+			if (!node.variableDeclaration?.name) return;
+			const identifiers = collectBindingElements(node.variableDeclaration.name);
+			for (const identifier of identifiers) {
+				const modifyingReferences = getModifyingReferences(identifier, sourceFile, typeChecker);
+				for (const reference of modifyingReferences) context.report({
+					message: "noExAssign",
+					range: {
+						begin: reference.getStart(sourceFile),
+						end: reference.getEnd()
+					}
+				});
+			}
+		} } };
+	}
 });
+//#endregion
+export { exceptionAssignments_default as default };
+
+//# sourceMappingURL=exceptionAssignments.js.map

package/lib/rules/explicitAnys.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports explicit uses of the any type.";
+    readonly id: "explicitAnys";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "noExplicitAny", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=explicitAnys.d.ts.map

package/lib/rules/explicitAnys.js

@@ -0,0 +1,55 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+//#region src/rules/explicitAnys.ts
+function isNodeWithinKeyofAny(node) {
+	return node.parent.kind === ts.SyntaxKind.TypeOperator && node.parent.operator === ts.SyntaxKind.KeyOfKeyword;
+}
+var explicitAnys_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports explicit uses of the any type.",
+		id: "explicitAnys",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { noExplicitAny: {
+		primary: "Avoid using the `any` type as it disables type checking for the annotated value.",
+		secondary: [
+			"Using `any` eliminates many of the benefits of TypeScript's type system.",
+			"It allows `any` operation on the value without compile-time checks.",
+			"Errors that could be caught at compile time may only appear at runtime."
+		],
+		suggestions: [
+			"Use `unknown` instead if you need to accept `any` value but want type safety.",
+			"Use a more specific type if the possible values are known.",
+			"For generic classes and functions, use type parameters to preserve type information across calls.",
+			"For keyof `any`, consider using `PropertyKey` instead."
+		]
+	} },
+	setup(context) {
+		return { visitors: { AnyKeyword: (node, { sourceFile }) => {
+			const isKeyofAny = isNodeWithinKeyofAny(node);
+			const range = getTSNodeRange(node, sourceFile);
+			context.report({
+				message: "noExplicitAny",
+				range,
+				suggestions: isKeyofAny ? [{
+					id: "propertyKey",
+					range: getTSNodeRange(node.parent, sourceFile),
+					text: "PropertyKey"
+				}] : [{
+					id: "unknown",
+					range,
+					text: "unknown"
+				}, {
+					id: "never",
+					range,
+					text: "never"
+				}]
+			});
+		} } };
+	}
+});
+//#endregion
+export { explicitAnys_default as default };
+
+//# sourceMappingURL=explicitAnys.js.map

package/lib/rules/exponentiationOperators.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Prefers the ** operator over Math.pow().";
+    readonly id: "exponentiationOperators";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferOperator", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=exponentiationOperators.d.ts.map

package/lib/rules/exponentiationOperators.js

@@ -0,0 +1,34 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts, { SyntaxKind } from "typescript";
+//#region src/rules/exponentiationOperators.ts
+var exponentiationOperators_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Prefers the ** operator over Math.pow().",
+		id: "exponentiationOperators",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { preferOperator: {
+		primary: "Prefer the more succinct `**` operator instead of Math.pow() for exponentiation.",
+		secondary: ["The `**` operator was introduced in ES2016 and is more readable.", "It also works with BigInt values, unlike Math.pow()."],
+		suggestions: ["`Replace Math.pow(base, exponent)` with `**`."]
+	} },
+	setup(context) {
+		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
+			if (!ts.isPropertyAccessExpression(node.expression) || node.expression.name.text !== "pow" || node.expression.expression.kind !== SyntaxKind.Identifier || node.expression.expression.text !== "Math" || node.arguments.length !== 2 || !isGlobalDeclarationOfName(node.expression.expression, "Math", typeChecker)) return;
+			const range = getTSNodeRange(node, sourceFile);
+			context.report({
+				fix: {
+					range,
+					text: node.arguments.map((argument) => argument.getText(sourceFile)).join(" ** ")
+				},
+				message: "preferOperator",
+				range
+			});
+		} } };
+	}
+});
+//#endregion
+export { exponentiationOperators_default as default };
+
+//# sourceMappingURL=exponentiationOperators.js.map

package/lib/rules/exportFromImports.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports imports that are re-exported and could use export...from syntax instead.";
+    readonly id: "exportFromImports";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferExportDefaultFrom" | "preferExportFrom" | "preferExportNamespaceFrom", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=exportFromImports.d.ts.map