@flint.fyi/ts 0.15.0 → 0.18.1

package/lib/rules/moduleSpecifierLists.js

@@ -0,0 +1,92 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/moduleSpecifierLists.ts
+function hasNamedBindings(node) {
+	const namedBindings = node.importClause?.namedBindings;
+	if (!namedBindings) return false;
+	return !ts$1.isNamedImports(namedBindings) || !!namedBindings.elements.length;
+}
+function hasNamespaceImport(node) {
+	const namedBindings = node.importClause?.namedBindings;
+	return namedBindings && ts$1.isNamespaceImport(namedBindings);
+}
+function isEmptyNamedImports(node) {
+	const namedBindings = node.importClause?.namedBindings;
+	return namedBindings && ts$1.isNamedImports(namedBindings) && !namedBindings.elements.length;
+}
+var moduleSpecifierLists_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Require non-empty specifier lists in import and export statements.",
+		id: "moduleSpecifierLists",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: {
+		emptyExportSpecifiers: {
+			primary: "Export statement with empty specifier list is unnecessary.",
+			secondary: ["Empty export braces serve no purpose and can be removed.", "If re-exporting from a module, ensure you specify what to export."],
+			suggestions: ["Remove the empty export statement."]
+		},
+		emptyImportSpecifiers: {
+			primary: "Import statement with empty specifier list is unnecessary.",
+			secondary: ["Empty import braces serve no purpose and can confuse readers.", "Use a side-effect import if you only need to run the module's code."],
+			suggestions: ["Remove the empty braces or convert to a side-effect import."]
+		}
+	},
+	setup(context) {
+		function createExportSuggestions(moduleSpecifier, node, sourceFile) {
+			const moduleSpecifierText = sourceFile.text.slice(moduleSpecifier.getStart(sourceFile), moduleSpecifier.getEnd());
+			return [{
+				id: "removeStatement",
+				range: getTSNodeRange(node, sourceFile),
+				text: ""
+			}, ...moduleSpecifierText ? [{
+				id: "convertToSideEffectImport",
+				range: getTSNodeRange(node, sourceFile),
+				text: `import ${moduleSpecifierText};`
+			}] : []];
+		}
+		function createImportSuggestions(importClause, node, sourceFile) {
+			const moduleSpecifier = sourceFile.text.slice(node.moduleSpecifier.getStart(sourceFile), node.moduleSpecifier.getEnd());
+			if (importClause.name) {
+				const defaultImportName = importClause.name.getText(sourceFile);
+				return [{
+					id: "removeEmptyBraces",
+					range: getTSNodeRange(node, sourceFile),
+					text: `import ${defaultImportName} from ${moduleSpecifier};`
+				}];
+			}
+			return [{
+				id: "removeStatement",
+				range: getTSNodeRange(node, sourceFile),
+				text: ""
+			}, ...importClause.phaseModifier === ts$1.SyntaxKind.TypeKeyword ? [] : [{
+				id: "convertToSideEffectImport",
+				range: getTSNodeRange(node, sourceFile),
+				text: `import ${moduleSpecifier};`
+			}]];
+		}
+		return { visitors: {
+			ExportDeclaration: (node, { sourceFile }) => {
+				if (node.moduleSpecifier === void 0 || !ts$1.isExportDeclaration(node) || !node.exportClause || !ts$1.isNamedExports(node.exportClause) || !!node.exportClause.elements.length) return;
+				context.report({
+					message: "emptyExportSpecifiers",
+					range: getTSNodeRange(node, sourceFile),
+					suggestions: createExportSuggestions(node.moduleSpecifier, node, sourceFile)
+				});
+			},
+			ImportDeclaration: (node, { sourceFile }) => {
+				if (hasNamedBindings(node) || hasNamespaceImport(node) || !isEmptyNamedImports(node) || !node.importClause) return;
+				context.report({
+					message: "emptyImportSpecifiers",
+					range: getTSNodeRange(node.importClause.namedBindings ?? node.importClause, sourceFile),
+					suggestions: createImportSuggestions(node.importClause, node, sourceFile)
+				});
+			}
+		} };
+	}
+});
+//#endregion
+export { moduleSpecifierLists_default as default };
+
+//# sourceMappingURL=moduleSpecifierLists.js.map

package/lib/rules/multilineAmbiguities.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports ambiguous multiline expressions that could be misinterpreted.";
+    readonly id: "multilineAmbiguities";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "ambiguity", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=multilineAmbiguities.d.ts.map

package/lib/rules/multilineAmbiguities.js

@@ -0,0 +1,64 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/multilineAmbiguities.ts
+var multilineAmbiguities_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports ambiguous multiline expressions that could be misinterpreted.",
+		id: "multilineAmbiguities",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { ambiguity: {
+		primary: "This ambiguous line break before {{ after }} will be misinterpreted as a {{ interpretation }}.",
+		secondary: ["When a line ends with an expression and the next line starts with {{ after }}, it may be interpreted as a {{ interpretation }} instead of two separate statements.", "This can lead to unexpected behavior and runtime errors that are difficult to debug."],
+		suggestions: ["Add a semicolon after the first line to make it clear they are separate statements.", "Alternatively, move the {{ after }} to the same line as the first expression if a {{ interpretation }} is intended."]
+	} },
+	setup(context) {
+		function checkMultilineDelimiter(expressionEnd, delimiterStart, after, interpretation, sourceFile) {
+			const { line: expressionEndLine } = sourceFile.getLineAndCharacterOfPosition(expressionEnd);
+			const { line: delimiterLine } = sourceFile.getLineAndCharacterOfPosition(delimiterStart);
+			if (expressionEndLine < delimiterLine) context.report({
+				data: {
+					after,
+					interpretation
+				},
+				message: "ambiguity",
+				range: {
+					begin: delimiterStart,
+					end: getLineEndPosition(delimiterLine, sourceFile)
+				}
+			});
+		}
+		return { visitors: {
+			CallExpression: (node, { sourceFile }) => {
+				if (!node.arguments.length || node.questionDotToken) return;
+				const openParen = findChildToken(node, ts$1.SyntaxKind.OpenParenToken, sourceFile);
+				if (!openParen) return;
+				checkMultilineDelimiter(getExpressionEnd(node, sourceFile), openParen.getStart(sourceFile), "parentheses", "function call", sourceFile);
+			},
+			ElementAccessExpression: (node, { sourceFile }) => {
+				if (node.questionDotToken) return;
+				const openBracket = findChildToken(node, ts$1.SyntaxKind.OpenBracketToken, sourceFile);
+				if (!openBracket) return;
+				checkMultilineDelimiter(node.expression.getEnd(), openBracket.getStart(sourceFile), "brackets", "property access", sourceFile);
+			},
+			TaggedTemplateExpression: (node, { sourceFile }) => {
+				checkMultilineDelimiter(node.tag.getEnd(), node.template.getStart(sourceFile), "a template literal", "tagged template", sourceFile);
+			}
+		} };
+	}
+});
+function findChildToken(node, kind, sourceFile) {
+	for (const child of node.getChildren(sourceFile)) if (child.kind === kind) return child;
+}
+function getExpressionEnd(node, sourceFile) {
+	return (node.typeArguments && findChildToken(node, ts$1.SyntaxKind.GreaterThanToken, sourceFile))?.getEnd() ?? node.expression.getEnd();
+}
+function getLineEndPosition(lineNumber, sourceFile) {
+	const nextLineStart = sourceFile.getLineStarts()[lineNumber + 1];
+	return nextLineStart === void 0 ? sourceFile.getEnd() : nextLineStart - 1;
+}
+//#endregion
+export { multilineAmbiguities_default as default };
+
+//# sourceMappingURL=multilineAmbiguities.js.map

package/lib/rules/namedDefaultExports.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports anonymous functions and classes as the default export.";
+    readonly id: "namedDefaultExports";
+    readonly presets: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "anonymousClass" | "anonymousFunction", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=namedDefaultExports.d.ts.map

package/lib/rules/namedDefaultExports.js

@@ -0,0 +1,60 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts, { SyntaxKind } from "typescript";
+//#region src/rules/namedDefaultExports.ts
+function hasDefaultModifier(modifiers) {
+	return modifiers?.some((mod) => mod.kind === SyntaxKind.DefaultKeyword);
+}
+function hasExportModifier(modifiers) {
+	return modifiers?.some((mod) => mod.kind === SyntaxKind.ExportKeyword);
+}
+var namedDefaultExports_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports anonymous functions and classes as the default export.",
+		id: "namedDefaultExports",
+		presets: ["stylisticStrict"]
+	},
+	messages: {
+		anonymousClass: {
+			primary: "This default-exported class is missing an informative name.",
+			secondary: ["Named default exports improve codebase searchability by ensuring consistent identifier use for a module's default export.", "When a class is anonymous, it becomes harder to find all usages and references in the codebase."],
+			suggestions: ["Add a name to the exported class."]
+		},
+		anonymousFunction: {
+			primary: "This default-exported function is missing an informative name.",
+			secondary: ["Named default exports improve codebase searchability by ensuring consistent identifier use for a module's default export.", "When a function is anonymous, it becomes harder to find all usages and references in the codebase."],
+			suggestions: ["Add a name to the exported function.", "Assign the arrow function to a named variable, then export it."]
+		}
+	},
+	setup(context) {
+		return { visitors: {
+			ClassDeclaration: (node, { sourceFile }) => {
+				if (hasExportModifier(node.modifiers) && hasDefaultModifier(node.modifiers) && !node.name) context.report({
+					message: "anonymousClass",
+					range: getTSNodeRange(node, sourceFile)
+				});
+			},
+			ExportAssignment: (node, { sourceFile }) => {
+				if (node.isExportEquals) return;
+				if (ts.isArrowFunction(node.expression) || ts.isFunctionExpression(node.expression) && !node.expression.name) context.report({
+					message: "anonymousFunction",
+					range: getTSNodeRange(node.expression, sourceFile)
+				});
+				else if (ts.isClassExpression(node.expression) && !node.expression.name) context.report({
+					message: "anonymousClass",
+					range: getTSNodeRange(node.expression, sourceFile)
+				});
+			},
+			FunctionDeclaration: (node, { sourceFile }) => {
+				if (hasExportModifier(node.modifiers) && hasDefaultModifier(node.modifiers) && !node.name) context.report({
+					message: "anonymousFunction",
+					range: getTSNodeRange(node, sourceFile)
+				});
+			}
+		} };
+	}
+});
+//#endregion
+export { namedDefaultExports_default as default };
+
+//# sourceMappingURL=namedDefaultExports.js.map

package/lib/rules/namespaceDeclarations.d.ts

@@ -1,9 +1,12 @@
-import { z } from "zod";
+import { z } from "zod/v4";
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports using legacy `namespace` declarations.";
     readonly id: "namespaceDeclarations";
-    readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "preferModules", {
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferModules", {
     readonly allowDeclarations: z.ZodDefault<z.ZodBoolean>;
     readonly allowDefinitionFiles: z.ZodDefault<z.ZodBoolean>;
 }>;

package/lib/rules/namespaceDeclarations.js

@@ -1,58 +1,37 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
 import * as tsutils from "ts-api-utils";
-import * as ts from "typescript";
-import { z } from "zod";
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports using legacy `namespace` declarations.",
-        id: "namespaceDeclarations",
-        preset: "logical",
-    },
-    messages: {
-        preferModules: {
-            primary: "Prefer using ECMAScript modules over legacy TypeScript namespaces.",
-            secondary: [
-                "Namespaces are a legacy feature of TypeScript that can lead to confusion and are not compatible with ECMAScript modules.",
-            ],
-            suggestions: [
-                "Modern codebases generally use `export` and `import` statements to define and use ECMAScript modules instead.",
-            ],
-        },
-    },
-    options: {
-        allowDeclarations: z
-            .boolean()
-            .default(false)
-            .describe("Whether to allow namespaces declared with the `declare` keyword."),
-        allowDefinitionFiles: z
-            .boolean()
-            .default(false)
-            .describe("Whether to allow namespaces in `.d.ts` and other definition files."),
-    },
-    setup(context) {
-        return {
-            visitors: {
-                ModuleDeclaration: (node, { options: { allowDeclarations, allowDefinitionFiles }, sourceFile }) => {
-                    if (allowDefinitionFiles && sourceFile.isDeclarationFile) {
-                        return;
-                    }
-                    if (node.parent.kind !== ts.SyntaxKind.SourceFile ||
-                        node.name.kind !== ts.SyntaxKind.Identifier ||
-                        node.name.text === "global") {
-                        return;
-                    }
-                    if (allowDeclarations &&
-                        tsutils.includesModifier(node.modifiers, ts.SyntaxKind.DeclareKeyword)) {
-                        return;
-                    }
-                    context.report({
-                        message: "preferModules",
-                        range: getTSNodeRange(node.getChildAt(0), sourceFile),
-                    });
-                },
-            },
-        };
-    },
+import { z } from "zod/v4";
+//#region src/rules/namespaceDeclarations.ts
+var namespaceDeclarations_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports using legacy `namespace` declarations.",
+		id: "namespaceDeclarations",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { preferModules: {
+		primary: "Prefer using ECMAScript modules over legacy TypeScript namespaces.",
+		secondary: ["Namespaces are a legacy feature of TypeScript that can lead to confusion and are not compatible with ECMAScript modules."],
+		suggestions: ["Modern codebases generally use `export` and `import` statements to define and use ECMAScript modules instead."]
+	} },
+	options: {
+		allowDeclarations: z.boolean().default(false).describe("Whether to allow namespaces declared with the `declare` keyword."),
+		allowDefinitionFiles: z.boolean().default(false).describe("Whether to allow namespaces in `.d.ts` and other definition files.")
+	},
+	setup(context) {
+		return { visitors: { ModuleDeclaration: (node, { options: { allowDeclarations, allowDefinitionFiles }, sourceFile }) => {
+			if (allowDefinitionFiles && sourceFile.isDeclarationFile) return;
+			if (node.parent.kind !== SyntaxKind.SourceFile || node.name.kind !== SyntaxKind.Identifier || node.name.text === "global") return;
+			if (allowDeclarations && tsutils.includesModifier(node.modifiers, SyntaxKind.DeclareKeyword)) return;
+			context.report({
+				message: "preferModules",
+				range: getTSNodeRange(node.getChildAt(0), sourceFile)
+			});
+		} } };
+	}
 });
+//#endregion
+export { namespaceDeclarations_default as default };
+
 //# sourceMappingURL=namespaceDeclarations.js.map

package/lib/rules/namespaceImplicitAmbientImports.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports declared namespaces that implicitly export all members.";
+    readonly id: "namespaceImplicitAmbientImports";
+    readonly presets: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "implicitExports", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=namespaceImplicitAmbientImports.d.ts.map

package/lib/rules/namespaceImplicitAmbientImports.js

@@ -0,0 +1,40 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts, { SyntaxKind } from "typescript";
+//#region src/rules/namespaceImplicitAmbientImports.ts
+function hasExportModifier(node) {
+	return !!(ts.canHaveModifiers(node) && ts.getModifiers(node)?.some((modifier) => modifier.kind === SyntaxKind.ExportKeyword));
+}
+function hasNamedExport(statements) {
+	return statements.some((statement) => statement.kind === SyntaxKind.ExportDeclaration && statement.exportClause?.kind === SyntaxKind.NamedExports);
+}
+function hasNonExportedMember(statements) {
+	return statements.some((statement) => !hasExportModifier(statement) && (statement.kind === SyntaxKind.TypeAliasDeclaration || statement.kind === SyntaxKind.InterfaceDeclaration || statement.kind === SyntaxKind.ClassDeclaration || statement.kind === SyntaxKind.EnumDeclaration || statement.kind === SyntaxKind.FunctionDeclaration || statement.kind === SyntaxKind.VariableStatement || statement.kind === SyntaxKind.ModuleDeclaration));
+}
+var namespaceImplicitAmbientImports_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports declared namespaces that implicitly export all members.",
+		id: "namespaceImplicitAmbientImports",
+		presets: ["stylisticStrict"]
+	},
+	messages: { implicitExports: {
+		primary: "Declared namespaces without explicit exports implicitly export all members.",
+		secondary: ["When a declared namespace has no named export statements, all its members are implicitly exported.", "This can lead to unintended exports and make it harder to understand what the namespace exposes."],
+		suggestions: ["Add an `export {};` statement to opt out of implicit exports, then explicitly export the members you intend to expose."]
+	} },
+	setup(context) {
+		return { visitors: { ModuleDeclaration: (node, { sourceFile }) => {
+			if (!node.modifiers?.some((modifier) => modifier.kind === SyntaxKind.DeclareKeyword) || node.name.kind !== SyntaxKind.Identifier || node.body?.kind !== SyntaxKind.ModuleBlock) return;
+			const statements = node.body.statements;
+			if (!statements.length || hasNamedExport(statements) || !hasNonExportedMember(statements)) return;
+			context.report({
+				message: "implicitExports",
+				range: getTSNodeRange(node, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+export { namespaceImplicitAmbientImports_default as default };
+
+//# sourceMappingURL=namespaceImplicitAmbientImports.js.map

package/lib/rules/namespaceKeywords.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using `module` keyword instead of `namespace` for TypeScript namespaces.";
+    readonly id: "namespaceKeywords";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferNamespace", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=namespaceKeywords.d.ts.map

package/lib/rules/namespaceKeywords.js

@@ -0,0 +1,40 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/namespaceKeywords.ts
+var namespaceKeywords_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports using `module` keyword instead of `namespace` for TypeScript namespaces.",
+		id: "namespaceKeywords",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { preferNamespace: {
+		primary: "The `namespace` keyword is preferred over `module` for TypeScript namespaces.",
+		secondary: [
+			"TypeScript originally used the `module` keyword to declare internal modules (namespaces).",
+			"The `namespace` keyword was later introduced to avoid confusion with ES6 modules.",
+			"Using `namespace` makes it clear you are defining a TypeScript namespace, not an ES6 module."
+		],
+		suggestions: ["Replace `module` with `namespace`."]
+	} },
+	setup(context) {
+		return { visitors: { ModuleDeclaration: (node, { sourceFile }) => {
+			if (node.name.kind === SyntaxKind.StringLiteral) return;
+			const moduleKeywordToken = node.getChildren(sourceFile).find((child) => child.kind === SyntaxKind.ModuleKeyword);
+			if (!moduleKeywordToken) return;
+			const range = getTSNodeRange(moduleKeywordToken, sourceFile);
+			context.report({
+				fix: {
+					range,
+					text: "namespace"
+				},
+				message: "preferNamespace",
+				range
+			});
+		} } };
+	}
+});
+//#endregion
+export { namespaceKeywords_default as default };
+
+//# sourceMappingURL=namespaceKeywords.js.map

package/lib/rules/nativeObjectExtensions.d.ts

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

package/lib/rules/nativeObjectExtensions.js

@@ -0,0 +1,114 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/nativeObjectExtensions.ts
+const nativeConstructors = new Set([
+	"AggregateError",
+	"Array",
+	"ArrayBuffer",
+	"BigInt",
+	"BigInt64Array",
+	"BigUint64Array",
+	"Boolean",
+	"DataView",
+	"Date",
+	"Error",
+	"EvalError",
+	"FinalizationRegistry",
+	"Float16Array",
+	"Float32Array",
+	"Float64Array",
+	"Function",
+	"Int8Array",
+	"Int16Array",
+	"Int32Array",
+	"Map",
+	"Number",
+	"Object",
+	"Promise",
+	"RangeError",
+	"ReferenceError",
+	"RegExp",
+	"Set",
+	"SharedArrayBuffer",
+	"String",
+	"Symbol",
+	"SyntaxError",
+	"TypeError",
+	"Uint8Array",
+	"Uint8ClampedArray",
+	"Uint16Array",
+	"Uint32Array",
+	"URIError",
+	"WeakMap",
+	"WeakRef",
+	"WeakSet"
+]);
+function getPrototypeObject(node) {
+	return ts$1.isIdentifier(node.expression) && node.expression;
+}
+function isPrototypeAccess(node) {
+	switch (node.kind) {
+		case ts$1.SyntaxKind.ElementAccessExpression: return ts$1.isStringLiteral(node.argumentExpression) && node.argumentExpression.text === "prototype";
+		case ts$1.SyntaxKind.PropertyAccessExpression: return node.name.text === "prototype";
+		default: return false;
+	}
+}
+var nativeObjectExtensions_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports extending the prototype of native JavaScript objects.",
+		id: "nativeObjectExtensions",
+		presets: ["javascript"]
+	},
+	messages: { noExtendNative: {
+		primary: "Extending the {{ name }} prototype modifies built-in behavior that other code depends on.",
+		secondary: [
+			"Adding properties to native prototypes affects all instances of that type across the codebase.",
+			"This can cause conflicts with other libraries that expect standard prototype behavior.",
+			"Future ECMAScript versions may add methods with the same name, causing unexpected behavior."
+		],
+		suggestions: ["Create a wrapper class or utility function instead of extending the prototype.", "Use composition rather than modifying the prototype chain."]
+	} },
+	setup(context) {
+		function checkNode(node, { sourceFile, typeChecker }) {
+			if (!isPrototypeAccess(node)) return;
+			const objectIdentifier = getPrototypeObject(node);
+			if (!objectIdentifier) return;
+			const name = objectIdentifier.text;
+			if (!nativeConstructors.has(name) || !isGlobalDeclarationOfName(objectIdentifier, name, typeChecker)) return;
+			switch (node.parent.kind) {
+				case ts$1.SyntaxKind.CallExpression: {
+					if (node.parent.arguments[0] !== node) break;
+					const callee = node.parent.expression;
+					if (!ts$1.isPropertyAccessExpression(callee) || !ts$1.isIdentifier(callee.expression) || callee.expression.text !== "Object" || callee.name.text !== "defineProperty" && callee.name.text !== "defineProperties" || !isGlobalDeclarationOfName(callee.expression, "Object", typeChecker)) break;
+					context.report({
+						data: { name },
+						message: "noExtendNative",
+						range: getTSNodeRange(node.parent, sourceFile)
+					});
+					break;
+				}
+				case ts$1.SyntaxKind.ElementAccessExpression:
+				case ts$1.SyntaxKind.PropertyAccessExpression: {
+					if (node.parent.expression !== node) break;
+					const grandparent = node.parent.parent;
+					if (!ts$1.isBinaryExpression(grandparent) || grandparent.operatorToken.kind !== ts$1.SyntaxKind.EqualsToken || grandparent.left !== node.parent) break;
+					context.report({
+						data: { name },
+						message: "noExtendNative",
+						range: getTSNodeRange(grandparent, sourceFile)
+					});
+					break;
+				}
+			}
+		}
+		return { visitors: {
+			ElementAccessExpression: checkNode,
+			PropertyAccessExpression: checkNode
+		} };
+	}
+});
+//#endregion
+export { nativeObjectExtensions_default as default };
+
+//# sourceMappingURL=nativeObjectExtensions.js.map

package/lib/rules/negativeIndexLengthMethods.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Prefer negative index over `.length - index` for `at`, `slice`, `splice`, and similar methods.";
+    readonly id: "negativeIndexLengthMethods";
+    readonly presets: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferNegativeIndex", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=negativeIndexLengthMethods.d.ts.map