@flint.fyi/ts 0.14.6 → 0.18.0

package/lib/rules/stringCodePoints.d.ts

@@ -0,0 +1,10 @@
+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: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferCodePointAt" | "preferFromCodePoint", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=stringCodePoints.d.ts.map

package/lib/rules/stringCodePoints.js

@@ -0,0 +1,50 @@
+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, { sourceFile, typeChecker }) {
+				if (node.name.text === "fromCharCode" && ts$1.isIdentifier(node.expression) && isGlobalDeclarationOfName(node.expression, "String", typeChecker)) context.report({
+					message: "preferFromCodePoint",
+					range: {
+						begin: node.name.getStart(sourceFile),
+						end: node.name.getEnd()
+					}
+				});
+			}
+		} };
+	}
+});
+//#endregion
+export { stringCodePoints_default as default };
+
+//# sourceMappingURL=stringCodePoints.js.map

package/lib/rules/stringSliceMethods.d.ts

@@ -0,0 +1,10 @@
+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: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferSliceOverSubstring", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=stringSliceMethods.d.ts.map

package/lib/rules/stringSliceMethods.js

@@ -0,0 +1,47 @@
+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 };
+
+//# sourceMappingURL=stringSliceMethods.js.map

package/lib/rules/stringStartsEndsWith.d.ts

@@ -0,0 +1,10 @@
+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: ["stylistic"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferEndsWith" | "preferStartsWith", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=stringStartsEndsWith.d.ts.map

package/lib/rules/stringStartsEndsWith.js

@@ -0,0 +1,79 @@
+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 };
+
+//# sourceMappingURL=stringStartsEndsWith.js.map

package/lib/rules/structuredCloneMethods.d.ts

@@ -0,0 +1,10 @@
+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: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferStructuredClone", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=structuredCloneMethods.d.ts.map

package/lib/rules/structuredCloneMethods.js

@@ -0,0 +1,39 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/structuredCloneMethods.ts
+function isJsonMethod(node, methodName, typeChecker) {
+	return ts$1.isCallExpression(node) && ts$1.isPropertyAccessExpression(node.expression) && ts$1.isIdentifier(node.expression.expression) && isGlobalDeclarationOfName(node.expression.expression, "JSON", typeChecker) && 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, { sourceFile, typeChecker }) {
+			if (!isJsonMethod(node, "parse", typeChecker) || node.arguments.length !== 1) return;
+			const argument = node.arguments[0];
+			if (ts$1.isSpreadElement(argument) || !isJsonMethod(argument, "stringify", typeChecker) || argument.arguments.length !== 1) return;
+			const stringifyArgument = argument.arguments[0];
+			if (ts$1.isSpreadElement(stringifyArgument)) return;
+			context.report({
+				message: "preferStructuredClone",
+				range: {
+					begin: node.getStart(sourceFile),
+					end: node.getEnd()
+				}
+			});
+		} } };
+	}
+});
+//#endregion
+export { structuredCloneMethods_default as default };
+
+//# sourceMappingURL=structuredCloneMethods.js.map

package/lib/rules/symbolDescriptions.d.ts

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

package/lib/rules/symbolDescriptions.js

@@ -1,41 +1,32 @@
-import * as ts from "typescript";
-import { typescriptLanguage } from "../language.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports Symbol() calls without description arguments.",
-        id: "symbolDescriptions",
-        preset: "stylistic",
-    },
-    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) => {
-                    if (!ts.isIdentifier(node.expression) ||
-                        node.expression.text !== "Symbol" ||
-                        node.arguments.length) {
-                        return;
-                    }
-                    context.report({
-                        message: "missingDescription",
-                        range: {
-                            begin: node.getStart(context.sourceFile),
-                            end: node.getEnd(),
-                        },
-                    });
-                },
-            },
-        };
-    },
+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 };
+
+//# sourceMappingURL=symbolDescriptions.js.map

package/lib/rules/thisAliases.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports assigning `this` to a variable.";
+    readonly id: "thisAliases";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "noThisAlias", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=thisAliases.d.ts.map

package/lib/rules/thisAliases.js

@@ -0,0 +1,44 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/thisAliases.ts
+var thisAliases_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports assigning `this` to a variable.",
+		id: "thisAliases",
+		presets: ["logical"]
+	},
+	messages: { noThisAlias: {
+		primary: "Assigning `this` to a variable is unnecessary with arrow functions.",
+		secondary: ["Arrow functions preserve the surrounding `this` context automatically.", "Aliasing `this` is a pre-ES2015 pattern that is no longer needed."],
+		suggestions: ["Use arrow functions to preserve the `this` context.", "Access `this` directly instead of through an alias."]
+	} },
+	setup(context) {
+		return { visitors: {
+			BinaryExpression(node, { sourceFile }) {
+				if (node.operatorToken.kind !== ts$1.SyntaxKind.EqualsToken || node.right.kind !== ts$1.SyntaxKind.ThisKeyword || !ts$1.isIdentifier(node.left)) return;
+				context.report({
+					message: "noThisAlias",
+					range: {
+						begin: node.getStart(sourceFile),
+						end: node.getEnd()
+					}
+				});
+			},
+			VariableDeclaration(node, { sourceFile }) {
+				if (node.initializer?.kind !== ts$1.SyntaxKind.ThisKeyword || !ts$1.isIdentifier(node.name)) return;
+				context.report({
+					message: "noThisAlias",
+					range: {
+						begin: node.getStart(sourceFile),
+						end: node.getEnd()
+					}
+				});
+			}
+		} };
+	}
+});
+//#endregion
+export { thisAliases_default as default };
+
+//# sourceMappingURL=thisAliases.js.map

package/lib/rules/thisBeforeSuper.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using `this` or `super` before calling `super()` in derived class constructors.";
+    readonly id: "thisBeforeSuper";
+    readonly presets: ["javascript"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "thisBeforeSuper" | "superBeforeSuper", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=thisBeforeSuper.d.ts.map

package/lib/rules/thisBeforeSuper.js

@@ -0,0 +1,86 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/thisBeforeSuper.ts
+function findAllThisOrSuper(node, sourceFile, results) {
+	if (isNestedScope(node)) return;
+	if (node.kind === ts$1.SyntaxKind.ThisKeyword) {
+		results.push(node);
+		return;
+	}
+	if (node.kind === ts$1.SyntaxKind.SuperKeyword && ts$1.isPropertyAccessExpression(node.parent)) {
+		results.push(node);
+		return;
+	}
+	ts$1.forEachChild(node, (child) => {
+		findAllThisOrSuper(child, sourceFile, results);
+	});
+}
+function findAllThisOrSuperBeforePosition(node, position, sourceFile, results) {
+	if (node.getStart(sourceFile) >= position) return;
+	if (isNestedScope(node)) return;
+	if (node.kind === ts$1.SyntaxKind.ThisKeyword) {
+		results.push(node);
+		return;
+	}
+	if (node.kind === ts$1.SyntaxKind.SuperKeyword && ts$1.isPropertyAccessExpression(node.parent)) {
+		results.push(node);
+		return;
+	}
+	ts$1.forEachChild(node, (child) => {
+		findAllThisOrSuperBeforePosition(child, position, sourceFile, results);
+	});
+}
+function findFirstSuperCall(node) {
+	if (isNestedScope(node)) return;
+	if (ts$1.isCallExpression(node) && node.expression.kind === ts$1.SyntaxKind.SuperKeyword) return node;
+	return ts$1.forEachChild(node, (child) => {
+		return findFirstSuperCall(child);
+	});
+}
+function isNestedScope(node) {
+	return ts$1.isFunctionDeclaration(node) || ts$1.isFunctionExpression(node) || ts$1.isArrowFunction(node) || ts$1.isClassDeclaration(node) || ts$1.isClassExpression(node);
+}
+var thisBeforeSuper_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports using `this` or `super` before calling `super()` in derived class constructors.",
+		id: "thisBeforeSuper",
+		presets: ["javascript"]
+	},
+	messages: {
+		superBeforeSuper: {
+			primary: "`super` property access is not allowed before `super()` in derived class constructors.",
+			secondary: ["Accessing `super.property` before calling `super()` throws a ReferenceError."],
+			suggestions: ["Move `super()` before any use of `super.property`."]
+		},
+		thisBeforeSuper: {
+			primary: "`this` is not allowed before `super()` in derived class constructors.",
+			secondary: ["Accessing `this` before calling `super()` throws a ReferenceError.", "The `super()` call must be the first statement that accesses the instance."],
+			suggestions: ["Move `super()` before any use of `this`."]
+		}
+	},
+	setup(context) {
+		return { visitors: { Constructor(node, { sourceFile }) {
+			if (!node.parent.heritageClauses) return;
+			if (!node.parent.heritageClauses.some((clause) => clause.token === ts$1.SyntaxKind.ExtendsKeyword) || !node.body) return;
+			const superCall = findFirstSuperCall(node.body);
+			const invalidNodes = [];
+			if (superCall) {
+				const superCallStart = superCall.getStart(sourceFile);
+				findAllThisOrSuperBeforePosition(node.body, superCallStart, sourceFile, invalidNodes);
+				for (const arg of superCall.arguments) findAllThisOrSuper(arg, sourceFile, invalidNodes);
+			} else findAllThisOrSuper(node.body, sourceFile, invalidNodes);
+			for (const invalidNode of invalidNodes) context.report({
+				message: invalidNode.kind === ts$1.SyntaxKind.ThisKeyword ? "thisBeforeSuper" : "superBeforeSuper",
+				range: {
+					begin: invalidNode.getStart(sourceFile),
+					end: invalidNode.getEnd()
+				}
+			});
+		} } };
+	}
+});
+//#endregion
+export { thisBeforeSuper_default as default };
+
+//# sourceMappingURL=thisBeforeSuper.js.map

package/lib/rules/throwErrors.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports throwing values that are not `Error` objects.";
+    readonly id: "throwErrors";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "throwError" | "throwUndefined", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=throwErrors.d.ts.map

package/lib/rules/throwErrors.js

@@ -0,0 +1,61 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
+import { declarationIncludesGlobal, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+import * as tsutils from "ts-api-utils";
+//#region src/rules/throwErrors.ts
+function isBuiltinErrorType(type) {
+	const symbol = type.getSymbol();
+	if (symbol?.getName() !== "Error") return false;
+	return !!symbol.getDeclarations()?.some(declarationIncludesGlobal);
+}
+function isErrorType(type) {
+	if (isBuiltinErrorType(type)) return true;
+	if (type.isUnion()) return type.types.every((t) => isErrorType(t));
+	if (type.isIntersection()) return type.types.some((t) => isErrorType(t));
+	const baseTypes = type.getBaseTypes();
+	if (baseTypes) {
+		for (const baseType of baseTypes) if (isErrorType(baseType)) return true;
+	}
+	return false;
+}
+var throwErrors_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports throwing values that are not `Error` objects.",
+		id: "throwErrors",
+		presets: ["logical"]
+	},
+	messages: {
+		throwError: {
+			primary: "Only `Error` objects should be thrown.",
+			secondary: ["Throwing non-`Error` values loses stack trace information.", "Error objects provide consistent behavior and debugging information."],
+			suggestions: ["Wrap the value in an `Error`: `throw new Error(value)`.", "Create a custom `Error` class for specific error types."]
+		},
+		throwUndefined: {
+			primary: "Throwing `undefined` provides no context and is hard to debug.",
+			secondary: ["Throw an `Error` to preserve stack trace and debugging details.", "If you need a custom error type, extend `Error`."],
+			suggestions: ["Throw a new `Error`: `throw new Error(\"message\")`.", "Create a custom `Error` class for specific error types."]
+		}
+	},
+	setup(context) {
+		return { visitors: { ThrowStatement(node, { sourceFile, typeChecker }) {
+			const type = getConstrainedTypeAtLocation(node.expression, typeChecker);
+			if (tsutils.isTypeFlagSet(type, ts$1.TypeFlags.Any | ts$1.TypeFlags.Unknown) || isErrorType(type)) return;
+			if (type.isUnion() ? type.types.every((t) => tsutils.isTypeFlagSet(t, ts$1.TypeFlags.Undefined)) : tsutils.isTypeFlagSet(type, ts$1.TypeFlags.Undefined)) {
+				context.report({
+					message: "throwUndefined",
+					range: getTSNodeRange(node.expression, sourceFile)
+				});
+				return;
+			}
+			context.report({
+				message: "throwError",
+				range: getTSNodeRange(node.expression, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+export { throwErrors_default as default };
+
+//# sourceMappingURL=throwErrors.js.map

package/lib/rules/topLevelAwaits.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports top-level await expressions in files that export values.";
+    readonly id: "topLevelAwaits";
+    readonly presets: ["logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "topLevelAwait", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=topLevelAwaits.d.ts.map

package/lib/rules/topLevelAwaits.js

@@ -0,0 +1,49 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts, { SyntaxKind } from "typescript";
+//#region src/rules/topLevelAwaits.ts
+function hasExportModifier(node) {
+	return !!(ts.canHaveModifiers(node) && ts.getModifiers(node)?.some((modifier) => modifier.kind === SyntaxKind.ExportKeyword));
+}
+function isInsideFunction(node) {
+	let current = node.parent;
+	while (current) {
+		if (ts.isFunctionDeclaration(current) || ts.isFunctionExpression(current) || ts.isArrowFunction(current) || ts.isMethodDeclaration(current) || ts.isConstructorDeclaration(current) || ts.isGetAccessorDeclaration(current) || ts.isSetAccessorDeclaration(current)) return true;
+		current = current.parent;
+	}
+	return false;
+}
+var topLevelAwaits_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports top-level await expressions in files that export values.",
+		id: "topLevelAwaits",
+		presets: ["logicalStrict"]
+	},
+	messages: { topLevelAwait: {
+		primary: "Top-level await in a module file causes imports from the module to wait on the asynchronous work.",
+		secondary: ["Modules using top-level await block their dependents until the await resolves.", "This can cause unexpected delays in application startup."],
+		suggestions: ["Wrap the await in an async function that is called at the appropriate time.", "Use dynamic imports with `.then()` for lazy loading."]
+	} },
+	setup(context) {
+		let fileHasExports;
+		return { visitors: {
+			AwaitExpression(node, { sourceFile }) {
+				if (!fileHasExports || isInsideFunction(node)) return;
+				context.report({
+					message: "topLevelAwait",
+					range: {
+						begin: node.getStart(sourceFile),
+						end: node.expression.getStart(sourceFile)
+					}
+				});
+			},
+			SourceFile(node) {
+				fileHasExports = node.statements.some((statement) => hasExportModifier(statement) || statement.kind === SyntaxKind.ExportAssignment || statement.kind === SyntaxKind.ExportDeclaration);
+			}
+		} };
+	}
+});
+//#endregion
+export { topLevelAwaits_default as default };
+
+//# sourceMappingURL=topLevelAwaits.js.map

package/lib/rules/tripleSlashReferenceValidity.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports invalid triple-slash reference directives.";
+    readonly id: "tripleSlashReferenceValidity";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "invalidDirective", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=tripleSlashReferenceValidity.d.ts.map