@flint.fyi/ts 0.14.6 → 0.18.0

package/lib/rules/octalEscapes.js

@@ -1,71 +1,58 @@
-import { typescriptLanguage } from "../language.js";
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+//#region src/rules/octalEscapes.ts
 /**
- * Finds the position and length of an octal escape sequence in a string.
- * Returns undefined if no octal escape is found.
- */
+* Finds the position and length of an octal escape sequence in a string.
+* Returns undefined if no octal escape is found.
+*/
 function findOctalEscape(text) {
-    // Remove quotes from the string literal
-    const content = text.slice(1, -1);
-    // Match octal escapes: \0 followed by [0-7], or \1-7 optionally followed by [0-7]
-    // But exclude escaped backslashes (\\)
-    const octalEscapePattern = /(?<!\\)\\0[0-7]|(?<!\\)\\[1-7][0-7]*/;
-    const match = octalEscapePattern.exec(content);
-    if (!match) {
-        return undefined;
-    }
-    // Add 1 to account for the opening quote
-    return {
-        index: match.index + 1,
-        length: match[0].length,
-    };
+	const content = text.slice(1, -1);
+	const match = /(?<!\\)\\0[0-7]|(?<!\\)\\[1-7][0-7]*/.exec(content);
+	if (!match) return;
+	return {
+		index: match.index + 1,
+		length: match[0].length
+	};
 }
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports using octal escape sequences in string literals.",
-        id: "octalEscapes",
-        preset: "logical",
-    },
-    messages: {
-        noOctalEscape: {
-            primary: "Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.",
-            secondary: [
-                "Octal escape sequences (e.g., `\\01`, `\\02`, `\\377`) are a deprecated feature in JavaScript that can lead to confusion and are forbidden in strict mode and template literals.",
-                "They are less readable than their modern alternatives and can cause portability issues.",
-            ],
-            suggestions: [
-                "Use hexadecimal escape sequences (e.g., `\\x01`) or Unicode escape sequences (e.g., `\\u0001`) instead.",
-            ],
-        },
-    },
-    setup(context) {
-        function checkNode(node) {
-            const text = node.getText(context.sourceFile);
-            const octalEscape = findOctalEscape(text);
-            if (!octalEscape) {
-                return;
-            }
-            const nodeStart = node.getStart(context.sourceFile);
-            context.report({
-                message: "noOctalEscape",
-                range: {
-                    begin: nodeStart + octalEscape.index,
-                    end: nodeStart + octalEscape.index + octalEscape.length,
-                },
-            });
-        }
-        return {
-            visitors: {
-                NoSubstitutionTemplateLiteral: checkNode,
-                StringLiteral: checkNode,
-                TemplateExpression: (node) => {
-                    // Check the head of the template
-                    checkNode(node.head);
-                    // Check each template span
-                    for (const span of node.templateSpans) {
-                        checkNode(span.literal);
-                    }
-                },
-            },
-        };
-    },
+var octalEscapes_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports using octal escape sequences in string literals.",
+		id: "octalEscapes",
+		presets: ["javascript"]
+	},
+	messages: { noOctalEscape: {
+		primary: "Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.",
+		secondary: ["Octal escape sequences (e.g., `\\01`, `\\02`, `\\377`) are a deprecated feature in JavaScript that can lead to confusion and are forbidden in strict mode and template literals.", "They are less readable than their modern alternatives and can cause portability issues."],
+		suggestions: ["Use hexadecimal escape sequences (e.g., `\\x01`) or Unicode escape sequences (e.g., `\\u0001`) instead."]
+	} },
+	setup(context) {
+		function checkNode(node, sourceFile) {
+			const octalEscape = findOctalEscape(node.getText(sourceFile));
+			if (!octalEscape) return;
+			const nodeStart = node.getStart(sourceFile);
+			context.report({
+				message: "noOctalEscape",
+				range: {
+					begin: nodeStart + octalEscape.index,
+					end: nodeStart + octalEscape.index + octalEscape.length
+				}
+			});
+		}
+		return { visitors: {
+			NoSubstitutionTemplateLiteral: (node, { sourceFile }) => {
+				checkNode(node, sourceFile);
+			},
+			StringLiteral: (node, { sourceFile }) => {
+				checkNode(node, sourceFile);
+			},
+			TemplateExpression: (node, { sourceFile }) => {
+				checkNode(node.head, sourceFile);
+				for (const span of node.templateSpans) checkNode(span.literal, sourceFile);
+			}
+		} };
+	}
 });
+//#endregion
+export { octalEscapes_default as default };
+
+//# sourceMappingURL=octalEscapes.js.map

package/lib/rules/octalNumbers.d.ts

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

package/lib/rules/octalNumbers.js

@@ -1,68 +1,55 @@
-import { typescriptLanguage } from "../language.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports using legacy octal numeric literals.",
-        id: "octalNumbers",
-        preset: "untyped",
-    },
-    messages: {
-        noOctalNumber: {
-            primary: "This legacy octal numeric literal evaluates to {{ raw }}. Did you mean that value, or to use a modern octal syntax such as {{ equivalent }}?",
-            secondary: [
-                "Legacy octal numeric literals (e.g., `077`, `0123`) are a deprecated feature in JavaScript that can lead to confusion and errors.",
-                "They are forbidden in strict mode and are less readable than their modern alternatives.",
-                "The digit `0` by itself is allowed as it represents zero, not an octal literal.",
-            ],
-            suggestions: [
-                "Use the explicit octal syntax (e.g., `0o77`) introduced in ES6, which is clearer and works in both strict and non-strict modes.",
-                "Remove the leading `0` if you intended to use the decimal value.",
-            ],
-        },
-    },
-    setup(context) {
-        return {
-            visitors: {
-                NumericLiteral: (node) => {
-                    const text = node.getText(context.sourceFile);
-                    // Check for legacy octal literal: starts with 0 followed by octal digits (0-7)
-                    // But not just "0" alone, and not modern formats like 0x, 0o, 0b
-                    // cspell:ignore xobi
-                    if (text.length > 1 &&
-                        text.startsWith("0") &&
-                        text[1] >= "0" &&
-                        text[1] <= "7" &&
-                        !/^0[xobi]/i.test(text)) {
-                        const range = {
-                            begin: node.getStart(context.sourceFile),
-                            end: node.getEnd(),
-                        };
-                        // Parse the octal value
-                        const octalValue = parseInt(text, 8);
-                        const modernOctalSyntax = `0o${text.slice(1)}`;
-                        const decimalWithoutLeadingZero = text.slice(1);
-                        context.report({
-                            data: {
-                                equivalent: modernOctalSyntax,
-                                raw: octalValue.toString(),
-                            },
-                            message: "noOctalNumber",
-                            range,
-                            suggestions: [
-                                {
-                                    id: "useModernOctalSyntax",
-                                    range,
-                                    text: modernOctalSyntax,
-                                },
-                                {
-                                    id: "removeLeadingZero",
-                                    range,
-                                    text: decimalWithoutLeadingZero,
-                                },
-                            ],
-                        });
-                    }
-                },
-            },
-        };
-    },
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import { nullThrows } from "@flint.fyi/utils";
+//#region src/rules/octalNumbers.ts
+var octalNumbers_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports using legacy octal numeric literals.",
+		id: "octalNumbers",
+		presets: ["javascript"]
+	},
+	messages: { noOctalNumber: {
+		primary: "This legacy octal numeric literal evaluates to {{ raw }}. Did you mean that value, or to use a modern octal syntax such as {{ equivalent }}?",
+		secondary: [
+			"Legacy octal numeric literals (e.g., `077`, `0123`) are a deprecated feature in JavaScript that can lead to confusion and errors.",
+			"They are forbidden in strict mode and are less readable than their modern alternatives.",
+			"The digit `0` by itself is allowed as it represents zero, not an octal literal."
+		],
+		suggestions: ["Use the explicit octal syntax (e.g., `0o77`) introduced in ES6, which is clearer and works in both strict and non-strict modes.", "Remove the leading `0` if you intended to use the decimal value."]
+	} },
+	setup(context) {
+		return { visitors: { NumericLiteral: (node, { sourceFile }) => {
+			const text = node.getText(sourceFile);
+			if (text.length > 1 && text.startsWith("0") && nullThrows(text[1], "Second character is expected to be present by prior length check") >= "0" && nullThrows(text[1], "Second character is expected to be present by prior length check") <= "7" && !/^0[xobi]/i.test(text)) {
+				const range = {
+					begin: node.getStart(sourceFile),
+					end: node.getEnd()
+				};
+				const octalValue = parseInt(text, 8);
+				const modernOctalSyntax = `0o${text.slice(1)}`;
+				const decimalWithoutLeadingZero = text.slice(1);
+				context.report({
+					data: {
+						equivalent: modernOctalSyntax,
+						raw: octalValue.toString()
+					},
+					message: "noOctalNumber",
+					range,
+					suggestions: [{
+						id: "useModernOctalSyntax",
+						range,
+						text: modernOctalSyntax
+					}, {
+						id: "removeLeadingZero",
+						range,
+						text: decimalWithoutLeadingZero
+					}]
+				});
+			}
+		} } };
+	}
 });
+//#endregion
+export { octalNumbers_default as default };
+
+//# sourceMappingURL=octalNumbers.js.map

package/lib/rules/operatorAssignmentShorthand.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Prefer assignment operator shorthand where possible.";
+    readonly id: "operatorAssignmentShorthand";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferShorthand", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=operatorAssignmentShorthand.d.ts.map

package/lib/rules/operatorAssignmentShorthand.js

@@ -0,0 +1,77 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, hasSameTokens, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+//#region src/rules/operatorAssignmentShorthand.ts
+const operatorTexts = new Map([
+	[ts.SyntaxKind.AmpersandToken, "&"],
+	[ts.SyntaxKind.AsteriskAsteriskToken, "**"],
+	[ts.SyntaxKind.AsteriskToken, "*"],
+	[ts.SyntaxKind.BarToken, "|"],
+	[ts.SyntaxKind.CaretToken, "^"],
+	[ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken, ">>>"],
+	[ts.SyntaxKind.GreaterThanGreaterThanToken, ">>"],
+	[ts.SyntaxKind.LessThanLessThanToken, "<<"],
+	[ts.SyntaxKind.MinusToken, "-"],
+	[ts.SyntaxKind.PercentToken, "%"],
+	[ts.SyntaxKind.PlusToken, "+"],
+	[ts.SyntaxKind.SlashToken, "/"]
+]);
+const commutativeOperatorsWithShorthand = new Set([
+	"&",
+	"*",
+	"^",
+	"|"
+]);
+const nonCommutativeOperatorsWithShorthand = new Set([
+	"%",
+	"**",
+	"+",
+	"-",
+	"/",
+	"<<",
+	">>",
+	">>>"
+]);
+var operatorAssignmentShorthand_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Prefer assignment operator shorthand where possible.",
+		id: "operatorAssignmentShorthand",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { preferShorthand: {
+		primary: "This `=` assignment can be replaced with an `{{ operator }}=` operator assignment.",
+		secondary: ["The shorthand operator assignment accomplishes the same operation with less code."],
+		suggestions: ["Switch the `=` assignment with an `{{ operator }}` operator assignment."]
+	} },
+	setup(context) {
+		function report(operator, node, right, sourceFile) {
+			const range = getTSNodeRange(node, sourceFile);
+			context.report({
+				data: { operator },
+				fix: {
+					range,
+					text: [
+						node.left.getText(sourceFile),
+						`${operator}=`,
+						right.getText(sourceFile)
+					].join(" ")
+				},
+				message: "preferShorthand",
+				range
+			});
+		}
+		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
+			if (node.operatorToken.kind !== ts.SyntaxKind.EqualsToken || !ts.isBinaryExpression(node.right)) return;
+			const operator = operatorTexts.get(node.right.operatorToken.kind);
+			if (!operator) return;
+			const isCommutative = commutativeOperatorsWithShorthand.has(operator);
+			if (!isCommutative && !nonCommutativeOperatorsWithShorthand.has(operator)) return;
+			if (hasSameTokens(node.left, node.right.left, sourceFile)) report(operator, node, node.right.right, sourceFile);
+			else if (isCommutative && hasSameTokens(node.left, node.right.right, sourceFile)) report(operator, node, node.right.left, sourceFile);
+		} } };
+	}
+});
+//#endregion
+export { operatorAssignmentShorthand_default as default };
+
+//# sourceMappingURL=operatorAssignmentShorthand.js.map

package/lib/rules/overloadSignaturesAdjacent.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Require that function overload signatures be consecutive.";
+    readonly id: "overloadSignaturesAdjacent";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "overloadSignatureSeparated", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=overloadSignaturesAdjacent.d.ts.map

package/lib/rules/overloadSignaturesAdjacent.js

@@ -0,0 +1,140 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts, { SyntaxKind } from "typescript";
+//#region src/rules/overloadSignaturesAdjacent.ts
+function getMemberMethod(member) {
+	switch (member.kind) {
+		case SyntaxKind.CallSignature: return {
+			callSignature: true,
+			name: "call",
+			static: false,
+			type: "normal"
+		};
+		case SyntaxKind.Constructor: return {
+			callSignature: false,
+			name: "constructor",
+			static: false,
+			type: "normal"
+		};
+		case SyntaxKind.ConstructSignature: return {
+			callSignature: false,
+			name: "new",
+			static: false,
+			type: "normal"
+		};
+		case SyntaxKind.ExportAssignment:
+		case SyntaxKind.ExportDeclaration: return;
+		case SyntaxKind.FunctionDeclaration: {
+			const name = member.name?.text;
+			if (name == null) return;
+			return {
+				callSignature: false,
+				name,
+				static: false,
+				type: "normal"
+			};
+		}
+		case SyntaxKind.MethodDeclaration:
+		case SyntaxKind.MethodSignature: {
+			const nameInfo = getNameFromPropertyName(member.name);
+			if (!nameInfo) return;
+			return {
+				callSignature: false,
+				name: nameInfo.name,
+				static: isStatic(member),
+				type: nameInfo.type
+			};
+		}
+	}
+	if (ts.isExportDeclaration(member) || ts.isImportDeclaration(member) || ts.isTypeAliasDeclaration(member) || ts.isInterfaceDeclaration(member) || ts.isClassDeclaration(member) || ts.isEnumDeclaration(member) || ts.isModuleDeclaration(member)) return;
+}
+function getMembers(node) {
+	switch (node.kind) {
+		case SyntaxKind.Block:
+		case SyntaxKind.ModuleBlock:
+		case SyntaxKind.SourceFile: return node.statements;
+		case SyntaxKind.ClassDeclaration:
+		case SyntaxKind.ClassExpression: return node.members;
+		case SyntaxKind.InterfaceDeclaration: return node.members;
+		case SyntaxKind.TypeLiteral: return node.members;
+	}
+}
+function getMethodDisplayName(method) {
+	if (method.static) return `static ${method.name}`;
+	if (method.type === "quoted") return `"${method.name}"`;
+	return method.name;
+}
+function getNameFromPropertyName(name) {
+	switch (name.kind) {
+		case SyntaxKind.ComputedPropertyName:
+			if (ts.isStringLiteral(name.expression)) return {
+				name: name.expression.text,
+				type: "quoted"
+			};
+			return;
+		case SyntaxKind.Identifier:
+		case SyntaxKind.NumericLiteral:
+		case SyntaxKind.PrivateIdentifier: return {
+			name: name.text,
+			type: "normal"
+		};
+		case SyntaxKind.StringLiteral: return {
+			name: name.text,
+			type: "quoted"
+		};
+		default: return;
+	}
+}
+function isSameMethod(method1, method2) {
+	return !!method2 && method1.name === method2.name && method1.static === method2.static && method1.callSignature === method2.callSignature && method1.type === method2.type;
+}
+function isStatic(node) {
+	return ts.canHaveModifiers(node) && !!node.modifiers?.some((mod) => mod.kind === SyntaxKind.StaticKeyword);
+}
+var overloadSignaturesAdjacent_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Require that function overload signatures be consecutive.",
+		id: "overloadSignaturesAdjacent",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { overloadSignatureSeparated: {
+		primary: "All {{ name }} signatures should be adjacent.",
+		secondary: ["Separating overload signatures makes code harder to read and maintain.", "Grouping all overloads for a function together makes it easier to read and understand that function."],
+		suggestions: ["Group all overload signatures for this function together."]
+	} },
+	setup(context) {
+		function checkNode(node, { sourceFile }) {
+			const members = getMembers(node);
+			let lastMethod;
+			const seenMethods = [];
+			for (const member of members) {
+				const method = getMemberMethod(member);
+				if (method == null) {
+					lastMethod = void 0;
+					continue;
+				}
+				const indexOfSameMethod = seenMethods.findIndex((seenMethod) => isSameMethod(method, seenMethod));
+				if (indexOfSameMethod > -1 && !isSameMethod(method, lastMethod)) context.report({
+					data: { name: getMethodDisplayName(method) },
+					message: "overloadSignatureSeparated",
+					range: getTSNodeRange(member, sourceFile)
+				});
+				else if (indexOfSameMethod === -1) seenMethods.push(method);
+				lastMethod = method;
+			}
+		}
+		return { visitors: {
+			Block: checkNode,
+			ClassDeclaration: checkNode,
+			ClassExpression: checkNode,
+			InterfaceDeclaration: checkNode,
+			ModuleBlock: checkNode,
+			SourceFile: checkNode,
+			TypeLiteral: checkNode
+		} };
+	}
+});
+//#endregion
+export { overloadSignaturesAdjacent_default as default };
+
+//# sourceMappingURL=overloadSignaturesAdjacent.js.map

package/lib/rules/parameterReassignments.d.ts

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

package/lib/rules/parameterReassignments.js

@@ -0,0 +1,76 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+//#region src/rules/parameterReassignments.ts
+function collectParameterNames(parameters) {
+	const names = /* @__PURE__ */ new Set();
+	const collectNames = (node) => {
+		if (node.kind === ts.SyntaxKind.Identifier) names.add(node.text);
+		else if (ts.isObjectBindingPattern(node)) {
+			for (const element of node.elements) if (!ts.isOmittedExpression(element)) collectNames(element.name);
+		} else if (ts.isArrayBindingPattern(node)) {
+			for (const element of node.elements) if (!ts.isOmittedExpression(element)) collectNames(element.name);
+		}
+	};
+	for (const parameter of parameters) collectNames(parameter.name);
+	return names;
+}
+var parameterReassignments_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Disallow reassignment of function parameters.",
+		id: "parameterReassignments",
+		presets: ["logical"]
+	},
+	messages: { parameterReassignment: {
+		primary: "Reassigning function parameters can make them more difficult to reason about.",
+		secondary: [
+			"Most code treats function parameters as constants.",
+			"Reassigning them inside the function removes that reference to the original value.",
+			"It's generally more understandable to write code that does not modify parameters."
+		],
+		suggestions: ["Use a new variable if you need to modify the value.", "Use a different pattern such as a helper function."]
+	} },
+	setup(context) {
+		const scopes = /* @__PURE__ */ new Map();
+		const checkParameterAssignment = (name, node, sourceFile) => {
+			let currentNode = node;
+			while (currentNode !== void 0) {
+				if (ts.isFunctionDeclaration(currentNode) || ts.isFunctionExpression(currentNode) || ts.isArrowFunction(currentNode)) {
+					if (scopes.get(currentNode)?.has(name)) context.report({
+						message: "parameterReassignment",
+						range: getTSNodeRange(node, sourceFile)
+					});
+					return;
+				}
+				currentNode = currentNode.parent;
+			}
+		};
+		const handleUnaryExpression = (node, { sourceFile }) => {
+			if ((node.operator === ts.SyntaxKind.PlusPlusToken || node.operator === ts.SyntaxKind.MinusMinusToken) && ts.isIdentifier(node.operand)) checkParameterAssignment(node.operand.text, node.operand, sourceFile);
+		};
+		return { visitors: {
+			ArrowFunction: (node) => {
+				scopes.set(node, collectParameterNames(node.parameters));
+			},
+			BinaryExpression: (node, { sourceFile }) => {
+				if (!(node.operatorToken.kind === ts.SyntaxKind.EqualsToken || node.operatorToken.kind === ts.SyntaxKind.PlusEqualsToken || node.operatorToken.kind === ts.SyntaxKind.MinusEqualsToken || node.operatorToken.kind === ts.SyntaxKind.AsteriskEqualsToken || node.operatorToken.kind === ts.SyntaxKind.SlashEqualsToken) || !ts.isIdentifier(node.left)) return;
+				checkParameterAssignment(node.left.text, node.left, sourceFile);
+			},
+			FunctionDeclaration: (node) => {
+				scopes.set(node, collectParameterNames(node.parameters));
+			},
+			FunctionExpression: (node) => {
+				scopes.set(node, collectParameterNames(node.parameters));
+			},
+			PostfixUnaryExpression: handleUnaryExpression,
+			PrefixUnaryExpression: handleUnaryExpression,
+			Program: () => {
+				scopes.clear();
+			}
+		} };
+	}
+});
+//#endregion
+export { parameterReassignments_default as default };
+
+//# sourceMappingURL=parameterReassignments.js.map

package/lib/rules/parseIntRadixes.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports parseInt calls that are missing or have an invalid radix parameter.";
+    readonly id: "parseIntRadixes";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "invalidRadix" | "missingRadix", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=parseIntRadixes.d.ts.map