@flint.fyi/ts 0.21.0 → 0.23.0

package/lib/rules/sizeComparisonOperators.js

@@ -1,146 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getStaticNumberValue, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-import { z as z$1 } from "zod/v4";
-//#region src/rules/sizeComparisonOperators.ts
-const sizePropertyNames = /* @__PURE__ */ new Set(["length", "size"]);
-function hasLogicalOrFallback(node) {
-	return ts$1.isBinaryExpression(node.parent) && node.parent.operatorToken.kind === ts$1.SyntaxKind.BarBarToken && node.parent.left === node;
-}
-function isDoubleNegation(node) {
-	return ts$1.isPrefixUnaryExpression(node) && node.operator === ts$1.SyntaxKind.ExclamationToken && ts$1.isPrefixUnaryExpression(node.operand) && node.operand.operator === ts$1.SyntaxKind.ExclamationToken;
-}
-function isInBooleanContext(node) {
-	if (isDoubleNegation(node)) return true;
-	switch (node.parent.kind) {
-		case ts$1.SyntaxKind.BinaryExpression: return node.parent.operatorToken.kind === ts$1.SyntaxKind.AmpersandAmpersandToken && node.parent.left === node;
-		case ts$1.SyntaxKind.CallExpression: return ts$1.isIdentifier(node.parent.expression) && node.parent.expression.text === "Boolean" && node.parent.arguments.length === 1 && node.parent.arguments[0] === node;
-		case ts$1.SyntaxKind.ConditionalExpression:
-		case ts$1.SyntaxKind.ForStatement: return node.parent.condition === node;
-		case ts$1.SyntaxKind.DoStatement:
-		case ts$1.SyntaxKind.IfStatement:
-		case ts$1.SyntaxKind.WhileStatement: return node.parent.expression === node;
-		case ts$1.SyntaxKind.PrefixUnaryExpression: return node.parent.operator === ts$1.SyntaxKind.ExclamationToken;
-		default: return false;
-	}
-}
-function isInNullishCoalescing(node) {
-	return ts$1.isBinaryExpression(node.parent) && node.parent.operatorToken.kind === ts$1.SyntaxKind.QuestionQuestionToken;
-}
-function isNegated(node) {
-	if (!ts$1.isPrefixUnaryExpression(node.parent) || node.parent.operator !== ts$1.SyntaxKind.ExclamationToken) return {
-		negated: false,
-		outerNode: node
-	};
-	if (ts$1.isPrefixUnaryExpression(node.parent.parent) && node.parent.parent.operator === ts$1.SyntaxKind.ExclamationToken) return {
-		negated: false,
-		outerNode: node.parent.parent
-	};
-	return {
-		negated: true,
-		outerNode: node.parent
-	};
-}
-function requiresBooleanType(node) {
-	switch (node.parent.kind) {
-		case ts$1.SyntaxKind.ArrowFunction:
-		case ts$1.SyntaxKind.PropertyDeclaration:
-		case ts$1.SyntaxKind.ReturnStatement:
-		case ts$1.SyntaxKind.VariableDeclaration: return true;
-		case ts$1.SyntaxKind.BinaryExpression:
-			if (node.parent.operatorToken.kind === ts$1.SyntaxKind.EqualsToken && node.parent.right === node) return true;
-			if (node.parent.operatorToken.kind === ts$1.SyntaxKind.BarBarToken || node.parent.operatorToken.kind === ts$1.SyntaxKind.AmpersandAmpersandToken) return node.parent.right === node;
-			return false;
-		case ts$1.SyntaxKind.ParenthesizedExpression: return requiresBooleanType(node.parent.expression);
-	}
-	return false;
-}
-var sizeComparisonOperators_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Enforce consistent style for `.length` and `.size` checks.",
-		id: "sizeComparisonOperators",
-		presets: ["stylisticStrict"]
-	},
-	messages: {
-		coercionNonZeroCheck: {
-			primary: "Prefer implicit boolean coercions instead of explicit `> 0` comparisons.",
-			secondary: ["Implicit boolean coercion of `.{{ property }}` is more concise."],
-			suggestions: ["Replace with `.{{ property }}`."]
-		},
-		coercionZeroCheck: {
-			primary: "Prefer implicit boolean coercions instead of explicit `=== 0` comparisons.",
-			secondary: ["Implicit boolean coercion of `.{{ property }}` is more concise."],
-			suggestions: ["Replace with `!.{{ property }}`."]
-		},
-		explicitNonZeroCheck: {
-			primary: "Prefer explicit `> 0` comparisons instead of implicit boolean coercions.",
-			secondary: ["Implicit boolean coercion of `.{{ property }}` can be confusing."],
-			suggestions: ["Replace with `.{{ property }} > 0`."]
-		},
-		explicitZeroCheck: {
-			primary: "Prefer explicit `=== 0` comparisons instead of implicit boolean coercions.",
-			secondary: ["Implicit boolean coercion of `.{{ property }}` can be confusing."],
-			suggestions: ["Replace with `.{{ property }} === 0`."]
-		}
-	},
-	options: { style: z$1.enum(["coercion", "explicit"]).default("coercion").describe("Which style to enforce: 'coercion' for implicit boolean checks like `if (arr.length)`, or 'explicit' for comparisons like `if (arr.length > 0)`.") },
-	setup(context) {
-		return { visitors: {
-			BinaryExpression: (node, { options, sourceFile }) => {
-				if (options.style !== "coercion") return;
-				const { left, operatorToken, right } = node;
-				if (!ts$1.isPropertyAccessExpression(left) || !sizePropertyNames.has(left.name.text) || !Object.is(getStaticNumberValue(right), 0)) return;
-				const isNonZeroCheck = operatorToken.kind === ts$1.SyntaxKind.GreaterThanToken || operatorToken.kind === ts$1.SyntaxKind.ExclamationEqualsEqualsToken || operatorToken.kind === ts$1.SyntaxKind.ExclamationEqualsToken;
-				const isZeroCheck = operatorToken.kind === ts$1.SyntaxKind.EqualsEqualsEqualsToken || operatorToken.kind === ts$1.SyntaxKind.EqualsEqualsToken || operatorToken.kind === ts$1.SyntaxKind.LessThanEqualsToken;
-				if (!isNonZeroCheck && !isZeroCheck) return;
-				const propertyText = left.getText(sourceFile);
-				const needsBoolean = requiresBooleanType(node);
-				if (isZeroCheck) context.report({
-					data: { property: left.name.text },
-					fix: {
-						range: getTSNodeRange(node, sourceFile),
-						text: `!${propertyText}`
-					},
-					message: "coercionZeroCheck",
-					range: getTSNodeRange(node, sourceFile)
-				});
-				else context.report({
-					data: { property: left.name.text },
-					fix: {
-						range: getTSNodeRange(node, sourceFile),
-						text: needsBoolean ? `!!${propertyText}` : propertyText
-					},
-					message: "coercionNonZeroCheck",
-					range: getTSNodeRange(node, sourceFile)
-				});
-			},
-			PropertyAccessExpression: (node, { options, sourceFile }) => {
-				if (options.style !== "explicit") return;
-				if (!sizePropertyNames.has(node.name.text) || hasLogicalOrFallback(node) || isInNullishCoalescing(node)) return;
-				const { negated, outerNode } = isNegated(node);
-				if (!isInBooleanContext(outerNode)) return;
-				const propertyText = node.getText(sourceFile);
-				if (negated) context.report({
-					data: { property: node.name.text },
-					fix: {
-						range: getTSNodeRange(outerNode, sourceFile),
-						text: `${propertyText} === 0`
-					},
-					message: "explicitZeroCheck",
-					range: getTSNodeRange(outerNode, sourceFile)
-				});
-				else context.report({
-					data: { property: node.name.text },
-					fix: {
-						range: getTSNodeRange(outerNode, sourceFile),
-						text: `${propertyText} > 0`
-					},
-					message: "explicitNonZeroCheck",
-					range: getTSNodeRange(outerNode, sourceFile)
-				});
-			}
-		} };
-	}
-});
-//#endregion
-export { sizeComparisonOperators_default as default };

package/lib/rules/sparseArrays.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports array literals with holes (sparse arrays).";
-    readonly id: "sparseArrays";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noSparseArray", undefined>;
-export default _default;

package/lib/rules/sparseArrays.js

@@ -1,41 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-import { nullThrows } from "@flint.fyi/utils";
-//#region src/rules/sparseArrays.ts
-var sparseArrays_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports array literals with holes (sparse arrays).",
-		id: "sparseArrays",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { noSparseArray: {
-		primary: "Sparse arrays with \"holes\" (empty slots) are misleading and behave differently from `undefined` values.",
-		secondary: ["Array methods treat holes inconsistently, which can lead to unexpected behavior and bugs.", "Using explicit `undefined` values makes the intent clear and ensures consistent behavior."],
-		suggestions: ["Replace holes with explicit `undefined` values.", "Remove unintended commas if the holes are accidental."]
-	} },
-	setup(context) {
-		return { visitors: { OmittedExpression: (node, { sourceFile }) => {
-			if (node.parent.kind !== SyntaxKind.ArrayLiteralExpression) return;
-			const syntaxList = node.parent.getChildren(sourceFile).find((child) => child.kind === SyntaxKind.SyntaxList);
-			if (!syntaxList) return;
-			const children = syntaxList.getChildren(sourceFile);
-			const omittedIndex = children.indexOf(node);
-			for (let i = omittedIndex + 1; i < children.length; i++) {
-				const child = nullThrows(children[i], "Child is expected to be present by the loop condition");
-				if (child.kind === SyntaxKind.CommaToken) {
-					context.report({
-						message: "noSparseArray",
-						range: {
-							begin: child.getStart(sourceFile),
-							end: child.getEnd()
-						}
-					});
-					break;
-				}
-			}
-		} } };
-	}
-});
-//#endregion
-export { sparseArrays_default as default };

package/lib/rules/staticMemberOnlyClasses.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports classes that only contain static members.";
-    readonly id: "staticMemberOnlyClasses";
-    readonly presets: readonly ["logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noStaticOnlyClass", undefined>;
-export default _default;

package/lib/rules/staticMemberOnlyClasses.js

@@ -1,75 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/staticMemberOnlyClasses.ts
-function hasDecorators(node) {
-	return node.modifiers?.some(ts.isDecorator) ?? false;
-}
-function hasExtendsClause(node) {
-	return node.heritageClauses?.some((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword) ?? false;
-}
-function hasPrivateConstructor(node) {
-	return node.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.PrivateKeyword) ?? false;
-}
-function hasStaticModifier(modifiers) {
-	return modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword) ?? false;
-}
-function isAbstractClass(node) {
-	return node.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.AbstractKeyword) ?? false;
-}
-function isEmptyConstructor(member) {
-	return !member.body?.statements.length && !member.parameters.length;
-}
-var staticMemberOnlyClasses_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports classes that only contain static members.",
-		id: "staticMemberOnlyClasses",
-		presets: ["logicalStrict"]
-	},
-	messages: { noStaticOnlyClass: {
-		primary: "This class only contains static members. Consider using module-level exports instead.",
-		secondary: ["Classes with only static members add unnecessary complexity.", "Module-level functions and constants are simpler and more idiomatic in JavaScript/TypeScript."],
-		suggestions: ["Use module-level functions and constants instead of a static-only class.", "If grouping is needed, use a plain object or namespace."]
-	} },
-	setup(context) {
-		function checkClass(node, { sourceFile }) {
-			if (hasExtendsClause(node) || isAbstractClass(node) || hasDecorators(node) || !node.members.length) return;
-			let hasNonStaticMember = false;
-			let hasPrivateConstructorMember = false;
-			for (const member of node.members) {
-				if (ts.isConstructorDeclaration(member)) {
-					if (hasPrivateConstructor(member)) {
-						hasPrivateConstructorMember = true;
-						break;
-					}
-					if (!isEmptyConstructor(member)) {
-						hasNonStaticMember = true;
-						break;
-					}
-					continue;
-				}
-				if (ts.isSemicolonClassElement(member) || ts.isClassStaticBlockDeclaration(member)) continue;
-				if (ts.isIndexSignatureDeclaration(member)) {
-					hasNonStaticMember = true;
-					break;
-				}
-				if ((ts.isPropertyDeclaration(member) || ts.isMethodDeclaration(member) || ts.isGetAccessorDeclaration(member) || ts.isSetAccessorDeclaration(member)) && !hasStaticModifier(member.modifiers)) {
-					hasNonStaticMember = true;
-					break;
-				}
-			}
-			if (hasPrivateConstructorMember || hasNonStaticMember) return;
-			const reportRange = getTSNodeRange(node.name ?? node, sourceFile);
-			context.report({
-				message: "noStaticOnlyClass",
-				range: reportRange
-			});
-		}
-		return { visitors: {
-			ClassDeclaration: checkClass,
-			ClassExpression: checkClass
-		} };
-	}
-});
-//#endregion
-export { staticMemberOnlyClasses_default as default };

package/lib/rules/stringCaseMismatches.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports string case method calls compared against literals with mismatched casing.";
-    readonly id: "stringCaseMismatches";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "mismatch", undefined>;
-export default _default;

package/lib/rules/stringCaseMismatches.js

@@ -1,53 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getStaticStringValue, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/stringCaseMismatches.ts
-function isLowerCase(text) {
-	return text === text.toLowerCase();
-}
-function isUpperCase(text) {
-	return text === text.toUpperCase();
-}
-var stringCaseMismatches_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports string case method calls compared against literals with mismatched casing.",
-		id: "stringCaseMismatches",
-		presets: ["logical"]
-	},
-	messages: { mismatch: {
-		primary: "This `{{ method }}()` call is compared against a string that is not {{ expectedCase }}.",
-		secondary: ["The comparison will always be {{ result }} because the casing doesn't match."],
-		suggestions: ["Change the compared string to {{ expectedCase }}: \"{{ corrected }}\"."]
-	} },
-	setup(context) {
-		return { visitors: { CallExpression(node, { sourceFile }) {
-			if (!ts$1.isPropertyAccessExpression(node.expression)) return;
-			if (node.expression.name.text !== "toLowerCase" && node.expression.name.text !== "toUpperCase" || node.arguments.length || !ts$1.isBinaryExpression(node.parent)) return;
-			const operator = node.parent.operatorToken.kind;
-			if (operator !== ts$1.SyntaxKind.EqualsEqualsToken && operator !== ts$1.SyntaxKind.EqualsEqualsEqualsToken && operator !== ts$1.SyntaxKind.ExclamationEqualsToken && operator !== ts$1.SyntaxKind.ExclamationEqualsEqualsToken) return;
-			const otherSide = node.parent.left === node ? node.parent.right : node.parent.left;
-			const value = getStaticStringValue(otherSide);
-			if (value === void 0) return;
-			const isToLower = node.expression.name.text === "toLowerCase";
-			const expectedCase = isToLower ? "lowercase" : "uppercase";
-			if (isToLower ? isLowerCase(value) : isUpperCase(value)) return;
-			const corrected = isToLower ? value.toLowerCase() : value.toUpperCase();
-			const isEquality = operator === ts$1.SyntaxKind.EqualsEqualsToken || operator === ts$1.SyntaxKind.EqualsEqualsEqualsToken;
-			context.report({
-				data: {
-					corrected,
-					expectedCase,
-					method: node.expression.name.text,
-					result: isEquality ? "false" : "true"
-				},
-				message: "mismatch",
-				range: {
-					begin: otherSide.getStart(sourceFile),
-					end: otherSide.getEnd()
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { stringCaseMismatches_default as default };

package/lib/rules/stringCodePoints.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports usage of charCodeAt and fromCharCode instead of their codePoint equivalents.";
-    readonly id: "stringCodePoints";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferCodePointAt" | "preferFromCodePoint", undefined>;
-export default _default;

package/lib/rules/stringCodePoints.js

@@ -1,48 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-import * as tsutils from "ts-api-utils";
-//#region src/rules/stringCodePoints.ts
-var stringCodePoints_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports usage of charCodeAt and fromCharCode instead of their codePoint equivalents.",
-		id: "stringCodePoints",
-		presets: ["logical"]
-	},
-	messages: {
-		preferCodePointAt: {
-			primary: "Prefer `codePointAt` over `charCodeAt` for proper Unicode support.",
-			secondary: ["charCodeAt only handles characters in the Basic Multilingual Plane (BMP).", "codePointAt correctly handles all Unicode code points, including emoji."],
-			suggestions: ["Replace with codePointAt()."]
-		},
-		preferFromCodePoint: {
-			primary: "Prefer `String.fromCodePoint` over `String.fromCharCode` for proper Unicode support.",
-			secondary: ["fromCharCode only handles code points up to U+FFFF.", "fromCodePoint correctly handles all Unicode code points."],
-			suggestions: ["Replace with String.fromCodePoint()."]
-		}
-	},
-	setup(context) {
-		return { visitors: {
-			CallExpression(node, { sourceFile, typeChecker }) {
-				if (ts$1.isPropertyAccessExpression(node.expression) && node.expression.name.text === "charCodeAt" && tsutils.isTypeFlagSet(typeChecker.getTypeAtLocation(node.expression.expression), ts$1.TypeFlags.StringLike)) context.report({
-					message: "preferCodePointAt",
-					range: {
-						begin: node.expression.name.getStart(sourceFile),
-						end: node.expression.name.getEnd()
-					}
-				});
-			},
-			PropertyAccessExpression(node, { program, sourceFile, typeChecker }) {
-				if (node.name.text === "fromCharCode" && ts$1.isIdentifier(node.expression) && isGlobalDeclarationOfName(node.expression, "String", typeChecker, program)) context.report({
-					message: "preferFromCodePoint",
-					range: {
-						begin: node.name.getStart(sourceFile),
-						end: node.name.getEnd()
-					}
-				});
-			}
-		} };
-	}
-});
-//#endregion
-export { stringCodePoints_default as default };

package/lib/rules/stringSliceMethods.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports usage of `substring` instead of slice for string operations.";
-    readonly id: "stringSliceMethods";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferSliceOverSubstring", undefined>;
-export default _default;

package/lib/rules/stringSliceMethods.js

@@ -1,45 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.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/stringSliceMethods.ts
-var stringSliceMethods_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports usage of `substring` instead of slice for string operations.",
-		id: "stringSliceMethods",
-		presets: ["logical"]
-	},
-	messages: { preferSliceOverSubstring: {
-		primary: "Prefer `slice` over `substring` for more consistent behavior.",
-		secondary: [
-			"`slice` has predictable behavior matching `Array.prototype.slice`.",
-			"`substring` auto-swaps arguments if start > end, which can be confusing.",
-			"`substring` also treats negative indices as 0, unlike `slice`."
-		],
-		suggestions: ["Replace with slice()."]
-	} },
-	setup(context) {
-		return { visitors: { CallExpression(node, { sourceFile, typeChecker }) {
-			if (ts$1.isPropertyAccessExpression(node.expression) && node.expression.name.text === "substring" && tsutils.isTypeFlagSet(getConstrainedTypeAtLocation(node, typeChecker), ts$1.TypeFlags.StringLike)) {
-				const args = node.arguments.map((arg) => arg.getText(sourceFile));
-				const receiver = node.expression.expression.getText(sourceFile);
-				const replacement = !args.length ? `${receiver}.slice()` : args.length === 1 ? `${receiver}.slice(${args[0]})` : `${receiver}.slice(${args[0]}, ${args[1]})`;
-				context.report({
-					message: "preferSliceOverSubstring",
-					range: getTSNodeRange(node.expression.name, sourceFile),
-					suggestions: [{
-						id: "replaceWithSlice",
-						range: {
-							begin: node.getStart(sourceFile),
-							end: node.getEnd()
-						},
-						text: replacement
-					}]
-				});
-			}
-		} } };
-	}
-});
-//#endregion
-export { stringSliceMethods_default as default };

package/lib/rules/stringStartsEndsWith.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports regex patterns that can be replaced with `endsWith` or `startsWith`.";
-    readonly id: "stringStartsEndsWith";
-    readonly presets: readonly ["stylistic"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferEndsWith" | "preferStartsWith", undefined>;
-export default _default;

package/lib/rules/stringStartsEndsWith.js

@@ -1,77 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/stringStartsEndsWith.ts
-const REGEX_METACHARACTERS = /[+[{(.?*|\\]/;
-function escapeString(str) {
-	return str.replace(/["'\\]/g, "\\$&");
-}
-function isSimpleString(pattern) {
-	return !REGEX_METACHARACTERS.test(pattern);
-}
-var stringStartsEndsWith_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports regex patterns that can be replaced with `endsWith` or `startsWith`.",
-		id: "stringStartsEndsWith",
-		presets: ["stylistic"]
-	},
-	messages: {
-		preferEndsWith: {
-			primary: "Prefer `endsWith()` over a regex with `$` for readability.",
-			secondary: ["`endsWith` is generally more readable than using a regular expression."],
-			suggestions: ["Replace the regular expression with `endsWith()`."]
-		},
-		preferStartsWith: {
-			primary: "Prefer `startsWith()` over a regex with `^` for readability.",
-			secondary: ["`startsWith` is generally more readable than using a regular expression."],
-			suggestions: ["Replace the regular expression with `startsWith()`."]
-		}
-	},
-	setup(context) {
-		return { visitors: { CallExpression(node, { sourceFile }) {
-			if (!ts$1.isPropertyAccessExpression(node.expression)) return;
-			if (node.expression.name.text !== "test") return;
-			const callee = node.expression.expression;
-			if (!ts$1.isRegularExpressionLiteral(callee)) return;
-			const regexText = callee.text;
-			const match = /^\/(.*)\/([gimsuy]*)$/.exec(regexText);
-			if (!match) return;
-			const pattern = match[1];
-			const flags = match[2];
-			if (flags.includes("i") || flags.includes("m")) return;
-			const argument = node.arguments[0];
-			if (!argument) return;
-			const argumentText = argument.getText(sourceFile);
-			const callRange = getTSNodeRange(node, sourceFile);
-			if (pattern.startsWith("^") && !pattern.endsWith("$")) {
-				const stringPart = pattern.slice(1);
-				if (isSimpleString(stringPart)) context.report({
-					fix: {
-						range: callRange,
-						text: `${argumentText}.startsWith("${escapeString(stringPart)}")`
-					},
-					message: "preferStartsWith",
-					range: {
-						begin: callee.getStart(sourceFile),
-						end: callee.getEnd()
-					}
-				});
-			} else if (pattern.endsWith("$") && !pattern.startsWith("^")) {
-				const stringPart = pattern.slice(0, -1);
-				if (isSimpleString(stringPart)) context.report({
-					fix: {
-						range: callRange,
-						text: `${argumentText}.endsWith("${escapeString(stringPart)}")`
-					},
-					message: "preferEndsWith",
-					range: {
-						begin: callee.getStart(sourceFile),
-						end: callee.getEnd()
-					}
-				});
-			}
-		} } };
-	}
-});
-//#endregion
-export { stringStartsEndsWith_default as default };

package/lib/rules/structuredCloneMethods.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports JSON.parse(JSON.stringify()) patterns that can use structuredClone.";
-    readonly id: "structuredCloneMethods";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferStructuredClone", undefined>;
-export default _default;

package/lib/rules/structuredCloneMethods.js

@@ -1,37 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { isCallExpression, isIdentifier, isPropertyAccessExpression, isSpreadElement } from "typescript";
-//#region src/rules/structuredCloneMethods.ts
-function isJsonMethod(node, methodName, typeChecker, program) {
-	return isCallExpression(node) && isPropertyAccessExpression(node.expression) && isIdentifier(node.expression.expression) && isGlobalDeclarationOfName(node.expression.expression, "JSON", typeChecker, program) && node.expression.expression.text === "JSON" && node.expression.name.text === methodName;
-}
-var structuredCloneMethods_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports JSON.parse(JSON.stringify()) patterns that can use structuredClone.",
-		id: "structuredCloneMethods",
-		presets: ["logical"]
-	},
-	messages: { preferStructuredClone: {
-		primary: "Prefer `structuredClone()` over `JSON.parse(JSON.stringify())`.",
-		secondary: ["structuredClone is the native deep cloning API available in modern JavaScript.", "It properly handles circular references and more data types than JSON methods."],
-		suggestions: ["Replace with structuredClone()."]
-	} },
-	setup(context) {
-		return { visitors: { CallExpression(node, { program, sourceFile, typeChecker }) {
-			if (!isJsonMethod(node, "parse", typeChecker, program) || node.arguments.length !== 1) return;
-			const argument = node.arguments[0];
-			if (isSpreadElement(argument) || !isJsonMethod(argument, "stringify", typeChecker, program) || argument.arguments.length !== 1) return;
-			const stringifyArgument = argument.arguments[0];
-			if (isSpreadElement(stringifyArgument)) return;
-			context.report({
-				message: "preferStructuredClone",
-				range: {
-					begin: node.getStart(sourceFile),
-					end: node.getEnd()
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { structuredCloneMethods_default as default };

package/lib/rules/symbolDescriptions.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports Symbol() calls without description arguments.";
-    readonly id: "symbolDescriptions";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "missingDescription", undefined>;
-export default _default;

package/lib/rules/symbolDescriptions.js

@@ -1,30 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/symbolDescriptions.ts
-var symbolDescriptions_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports Symbol() calls without description arguments.",
-		id: "symbolDescriptions",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { missingDescription: {
-		primary: "Symbols without descriptions are more difficult to debug or reason about.",
-		secondary: ["Creating a symbol without a description makes debugging difficult, as the symbol's purpose isn't clear when inspecting it.", "While the description doesn't affect the symbol's uniqueness, it appears in the symbol's string representation and can be accessed via `Symbol.prototype.description`."],
-		suggestions: ["Add a descriptive string argument to the Symbol constructor that explains the symbol's purpose."]
-	} },
-	setup(context) {
-		return { visitors: { CallExpression: (node, { sourceFile }) => {
-			if (node.expression.kind !== SyntaxKind.Identifier || node.expression.text !== "Symbol" || node.arguments.length) return;
-			context.report({
-				message: "missingDescription",
-				range: {
-					begin: node.getStart(sourceFile),
-					end: node.getEnd()
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { symbolDescriptions_default as default };

package/lib/rules/thisAliases.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports assigning `this` to a variable.";
-    readonly id: "thisAliases";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noThisAlias", undefined>;
-export default _default;