@flint.fyi/ts 0.21.0 → 0.23.0

package/lib/rules/enumValueDuplicates.js

@@ -1,43 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getStaticValue, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/enumValueDuplicates.ts
-var enumValueDuplicates_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports enum members with duplicate values.",
-		id: "enumValueDuplicates",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { duplicateValue: {
-		primary: "Enum member '{{ name }}' has a duplicate value '{{ value }}' which is already used by '{{ firstMember }}'.",
-		secondary: ["Duplicate enum values can lead to hard-to-track bugs since different members may be indistinguishable at runtime.", "When accessing enum members by value, only one of the duplicate members will be returned."],
-		suggestions: ["Use a unique value for each enum member.", "If duplication is intentional (e.g., for aliasing), consider using a type union instead."]
-	} },
-	setup(context) {
-		return { visitors: { EnumDeclaration: (node, { sourceFile }) => {
-			const seenValues = /* @__PURE__ */ new Map();
-			for (const member of node.members) {
-				if (!member.initializer) continue;
-				const value = getStaticValue(member.initializer)?.value;
-				if (typeof value !== "number" && typeof value !== "string") continue;
-				const memberName = member.name.kind === SyntaxKind.Identifier ? member.name.text : member.name.getText(sourceFile);
-				const firstMember = seenValues.get(value);
-				if (firstMember === void 0) {
-					seenValues.set(value, memberName);
-					continue;
-				}
-				context.report({
-					data: {
-						firstMember,
-						name: memberName,
-						value: String(value)
-					},
-					message: "duplicateValue",
-					range: getTSNodeRange(member, sourceFile)
-				});
-			}
-		} } };
-	}
-});
-//#endregion
-export { enumValueDuplicates_default as default };

package/lib/rules/equalityOperatorNegations.d.ts

@@ -1,8 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports negated expressions on the left side of equality checks.";
-    readonly id: "equalityOperatorNegations";
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "negatedEquality", undefined>;
-export default _default;

package/lib/rules/equalityOperatorNegations.js

@@ -1,58 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage, unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/equalityOperatorNegations.ts
-const equalityOperators = /* @__PURE__ */ new Set([
-	SyntaxKind.EqualsEqualsEqualsToken,
-	SyntaxKind.EqualsEqualsToken,
-	SyntaxKind.ExclamationEqualsEqualsToken,
-	SyntaxKind.ExclamationEqualsToken
-]);
-const operatorStrings = /* @__PURE__ */ new Map([
-	[SyntaxKind.EqualsEqualsEqualsToken, "==="],
-	[SyntaxKind.EqualsEqualsToken, "=="],
-	[SyntaxKind.ExclamationEqualsEqualsToken, "!=="],
-	[SyntaxKind.ExclamationEqualsToken, "!="]
-]);
-const negatedOperators = /* @__PURE__ */ new Map([
-	[SyntaxKind.EqualsEqualsEqualsToken, "!=="],
-	[SyntaxKind.EqualsEqualsToken, "!="],
-	[SyntaxKind.ExclamationEqualsEqualsToken, "==="],
-	[SyntaxKind.ExclamationEqualsToken, "=="]
-]);
-var equalityOperatorNegations_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports negated expressions on the left side of equality checks.",
-		id: "equalityOperatorNegations"
-	},
-	messages: { negatedEquality: {
-		primary: "Negating the left operand of '{{ operator }}' is likely a mistake.",
-		secondary: ["The logical not operator (!) applies to the left operand before the equality comparison.", "This converts the left operand to a boolean before comparing, which is rarely intended."],
-		suggestions: ["Use the opposite equality operator ('{{ suggested }}') and remove the negation."]
-	} },
-	setup(context) {
-		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
-			if (!equalityOperators.has(node.operatorToken.kind)) return;
-			const left = unwrapParenthesizedNode(node.left);
-			if (left.kind !== SyntaxKind.PrefixUnaryExpression || left.operator !== SyntaxKind.ExclamationToken) return;
-			const innerExpression = unwrapParenthesizedNode(left.operand);
-			if (innerExpression.kind === SyntaxKind.PrefixUnaryExpression && innerExpression.operator === SyntaxKind.ExclamationToken) return;
-			const begin = left.getStart(sourceFile);
-			const operator = operatorStrings.get(node.operatorToken.kind);
-			const suggested = negatedOperators.get(node.operatorToken.kind);
-			context.report({
-				data: {
-					operator,
-					suggested
-				},
-				message: "negatedEquality",
-				range: {
-					begin,
-					end: begin + 1
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { equalityOperatorNegations_default as default };

package/lib/rules/equalityOperators.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Enforces consistent use of strict equality operators (=== and !==) over loose equality operators (== and !=) for non-nullish comparisons.";
-    readonly id: "equalityOperators";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferStrictEquality", undefined>;
-export default _default;

package/lib/rules/equalityOperators.js

@@ -1,42 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { isNullishLiteral, toEqualityOperator, toStrictOperator } from "./utils/equalityOperators.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/equalityOperators.ts
-var equalityOperators_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Enforces consistent use of strict equality operators (=== and !==) over loose equality operators (== and !=) for non-nullish comparisons.",
-		id: "equalityOperators",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { preferStrictEquality: {
-		primary: "Use the more precise strict equality ('{{ strictOperator }}') instead of the loose '{{ looseOperator }}'.",
-		secondary: ["The loose equality operators '=='/'!=' perform arcane type coercion and are difficult to reason about.", "Use strict equality operators '==='/'!==' instead."],
-		suggestions: ["Replace '{{ looseOperator }}' with '{{ strictOperator }}'."]
-	} },
-	setup(context) {
-		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
-			const operator = toEqualityOperator(node.operatorToken.kind);
-			if (operator == null) return;
-			if (isNullishLiteral(node.left) || isNullishLiteral(node.right)) return;
-			if (operator === "==" || operator === "!=") {
-				const strictOperator = toStrictOperator(operator);
-				const operatorRange = getTSNodeRange(node.operatorToken, sourceFile);
-				context.report({
-					data: {
-						looseOperator: operator,
-						strictOperator
-					},
-					message: "preferStrictEquality",
-					range: operatorRange,
-					suggestions: [{
-						id: "useStrictOperator",
-						range: operatorRange,
-						text: strictOperator
-					}]
-				});
-			}
-		} } };
-	}
-});
-//#endregion
-export { equalityOperators_default as default };

package/lib/rules/errorMessages.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Requires a message value when creating a built-in error.";
-    readonly id: "errorMessages";
-    readonly presets: readonly ["logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "missingMessage", undefined>;
-export default _default;

package/lib/rules/errorMessages.js

@@ -1,54 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getStaticStringValue, getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/errorMessages.ts
-const errorConstructors = [
-	"AggregateError",
-	"Error",
-	"EvalError",
-	"RangeError",
-	"ReferenceError",
-	"SyntaxError",
-	"TypeError",
-	"URIError"
-];
-function getErrorConstructorWithoutMessage(node, typeChecker, program) {
-	if (node.expression.kind !== SyntaxKind.Identifier || hasValidMessageArgument(node.arguments)) return false;
-	return errorConstructors.find((errorConstructor) => isGlobalDeclarationOfName(node.expression, errorConstructor, typeChecker, program));
-}
-function hasValidMessageArgument(args) {
-	if (!args?.length) return false;
-	const firstArgument = args[0];
-	return !!firstArgument && getStaticStringValue(firstArgument) !== "" && !isUndefinedLiteral(firstArgument);
-}
-function isUndefinedLiteral(node) {
-	return node.kind === SyntaxKind.Identifier && node.text === "undefined";
-}
-var errorMessages_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Requires a message value when creating a built-in error.",
-		id: "errorMessages",
-		presets: ["logicalStrict"]
-	},
-	messages: { missingMessage: {
-		primary: "`{{ errorConstructor }}`s created without a message are generally harder to debug.",
-		secondary: ["Error instances without messages are harder to debug because they don't explain what went wrong.", "A descriptive error message helps developers understand and fix issues more quickly."],
-		suggestions: ["Provide a string message describing what caused the error."]
-	} },
-	setup(context) {
-		function checkNode(node, { program, sourceFile, typeChecker }) {
-			const errorConstructor = getErrorConstructorWithoutMessage(node, typeChecker, program);
-			if (errorConstructor) context.report({
-				data: { errorConstructor },
-				message: "missingMessage",
-				range: getTSNodeRange(node.expression, sourceFile)
-			});
-		}
-		return { visitors: {
-			CallExpression: checkNode,
-			NewExpression: checkNode
-		} };
-	}
-});
-//#endregion
-export { errorMessages_default as default };

package/lib/rules/errorSubclassProperties.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports incorrect Error subclass definitions that don't follow best practices.";
-    readonly id: "errorSubclassProperties";
-    readonly presets: readonly ["logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "invalidClassName" | "missingName" | "redundantMessage" | "useConstructorName" | "wrongName", undefined>;
-export default _default;

package/lib/rules/errorSubclassProperties.js

@@ -1,142 +0,0 @@
-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, { program, sourceFile, typeChecker }) => {
-			if (!isErrorSubclass(node, typeChecker, program)) 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 };

package/lib/rules/errorUnnecessaryCaptureStackTraces.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports unnecessary Error.captureStackTrace() calls in Error subclass constructors.";
-    readonly id: "errorUnnecessaryCaptureStackTraces";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessaryCaptureStackTrace", undefined>;
-export default _default;

package/lib/rules/errorUnnecessaryCaptureStackTraces.js

@@ -1,53 +0,0 @@
-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, { program, sourceFile, typeChecker }) => {
-			if (!isErrorSubclass(node, typeChecker, program)) 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 };

package/lib/rules/escapeSequenceCasing.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports escape sequences with lowercase hexadecimal characters.";
-    readonly id: "escapeSequenceCasing";
-    readonly presets: readonly ["stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "useUppercase", undefined>;
-export default _default;

package/lib/rules/escapeSequenceCasing.js

@@ -1,73 +0,0 @@
-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 };

package/lib/rules/evals.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports uses of the eval function.";
-    readonly id: "evals";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noEval", undefined>;
-export default _default;

package/lib/rules/evals.js

@@ -1,29 +0,0 @@
-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, { program, sourceFile, typeChecker }) => {
-			if (isGlobalDeclarationOfName(node.expression, "eval", typeChecker, program)) context.report({
-				message: "noEval",
-				range: getTSNodeRange(node.expression, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { evals_default as default };

package/lib/rules/evolvingVariableTypes.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports variables declared without type annotation or initializer.";
-    readonly id: "evolvingVariableTypes";
-    readonly presets: readonly ["stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "implicitAny", undefined>;
-export default _default;

package/lib/rules/evolvingVariableTypes.js

@@ -1,31 +0,0 @@
-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 };

package/lib/rules/exceptionAssignments.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports reassigning exception parameters in catch clauses.";
-    readonly id: "exceptionAssignments";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noExAssign", undefined>;
-export default _default;