@flint.fyi/ts 0.20.0 → 0.22.0

package/lib/rules/irregularWhitespaces.js

@@ -1,97 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-import { z } from "zod/v4";
-//#region src/rules/irregularWhitespaces.ts
-function findIrregularWhitespaces(text) {
-	const irregularWhitespacePattern = /[\f\v\x85\ufeff\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u202f\u205f\u3000\u2028\u2029]/gu;
-	const matches = [];
-	let match;
-	while ((match = irregularWhitespacePattern.exec(text)) !== null) matches.push({
-		index: match.index,
-		length: match[0].length
-	});
-	return matches;
-}
-function isInRange(position, start, end) {
-	return position >= start && position < end;
-}
-var irregularWhitespaces_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports irregular whitespace characters that can cause issues with code parsing and display.",
-		id: "irregularWhitespaces",
-		presets: ["logical"]
-	},
-	messages: { irregularWhitespace: {
-		primary: "Irregular whitespace characters can cause unexpected behavior and display issues.",
-		secondary: [
-			"Irregular whitespace includes characters like non-breaking spaces (\\u00A0), zero-width spaces (\\u200B), and various Unicode space characters.",
-			"These characters are often invisible or look like regular spaces, but may be interpreted differently by tools and parsers.",
-			"They can be accidentally introduced through copy-paste from external sources."
-		],
-		suggestions: ["Replace irregular whitespace with regular spaces or tabs.", "Remove the whitespace if it is unnecessary."]
-	} },
-	options: {
-		skipComments: z.boolean().default(false).describe("Whether to allow irregular whitespace in comments."),
-		skipJSXText: z.boolean().default(false).describe("Whether to allow irregular whitespace in JSX text content."),
-		skipRegularExpressions: z.boolean().default(false).describe("Whether to allow irregular whitespace in regular expression literals."),
-		skipTemplates: z.boolean().default(false).describe("Whether to allow irregular whitespace in template literals.")
-	},
-	setup(context) {
-		return { visitors: { SourceFile: (node, { options, sourceFile }) => {
-			const text = sourceFile.getFullText();
-			const allMatches = findIrregularWhitespaces(text);
-			if (!allMatches.length) return;
-			const excludedRanges = [];
-			function collectExcludedRanges(astNode) {
-				if (astNode.kind === ts$1.SyntaxKind.StringLiteral) excludedRanges.push({
-					end: astNode.getEnd(),
-					start: astNode.getStart(sourceFile)
-				});
-				if (options.skipRegularExpressions && astNode.kind === ts$1.SyntaxKind.RegularExpressionLiteral) excludedRanges.push({
-					end: astNode.getEnd(),
-					start: astNode.getStart(sourceFile)
-				});
-				if (options.skipTemplates && (astNode.kind === ts$1.SyntaxKind.NoSubstitutionTemplateLiteral || astNode.kind === ts$1.SyntaxKind.TemplateHead || astNode.kind === ts$1.SyntaxKind.TemplateMiddle || astNode.kind === ts$1.SyntaxKind.TemplateTail)) excludedRanges.push({
-					end: astNode.getEnd(),
-					start: astNode.getStart(sourceFile)
-				});
-				if (options.skipJSXText && astNode.kind === ts$1.SyntaxKind.JsxText) excludedRanges.push({
-					end: astNode.getEnd(),
-					start: astNode.getFullStart()
-				});
-				ts$1.forEachChild(astNode, collectExcludedRanges);
-			}
-			collectExcludedRanges(node);
-			if (options.skipComments) {
-				const commentRanges = [...ts$1.getLeadingCommentRanges(text, 0) ?? []];
-				function collectCommentRanges(astNode) {
-					const leading = ts$1.getLeadingCommentRanges(text, astNode.getFullStart());
-					if (leading) commentRanges.push(...leading);
-					const trailing = ts$1.getTrailingCommentRanges(text, astNode.getEnd());
-					if (trailing) commentRanges.push(...trailing);
-					ts$1.forEachChild(astNode, collectCommentRanges);
-				}
-				collectCommentRanges(node);
-				for (const range of commentRanges) excludedRanges.push({
-					end: range.end,
-					start: range.pos
-				});
-			}
-			for (const match of allMatches) {
-				if (excludedRanges.some((range) => isInRange(match.index, range.start, range.end))) continue;
-				context.report({
-					message: "irregularWhitespace",
-					range: {
-						begin: match.index,
-						end: match.index + match.length
-					}
-				});
-			}
-		} } };
-	}
-});
-//#endregion
-export { irregularWhitespaces_default as default };
-
-//# sourceMappingURL=irregularWhitespaces.js.map

package/lib/rules/isNaNComparisons.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports comparisons with NaN, which should use Number.isNaN() instead.";
-    readonly id: "isNaNComparisons";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "useIsNaN", undefined>;
-export default _default;
-//# sourceMappingURL=isNaNComparisons.d.ts.map

package/lib/rules/isNaNComparisons.js

@@ -1,43 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage, unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/isNaNComparisons.ts
-const comparisonOperators = new Set([
-	SyntaxKind.EqualsEqualsEqualsToken,
-	SyntaxKind.EqualsEqualsToken,
-	SyntaxKind.ExclamationEqualsEqualsToken,
-	SyntaxKind.ExclamationEqualsToken,
-	SyntaxKind.GreaterThanEqualsToken,
-	SyntaxKind.GreaterThanToken,
-	SyntaxKind.LessThanEqualsToken,
-	SyntaxKind.LessThanToken
-]);
-var isNaNComparisons_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports comparisons with NaN, which should use Number.isNaN() instead.",
-		id: "isNaNComparisons",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { useIsNaN: {
-		primary: "Use `Number.isNaN()` instead of comparing with `NaN`.",
-		secondary: ["`NaN` is not equal to anything, including itself, so comparisons with `NaN` always return `false`."],
-		suggestions: ["Use `Number.isNaN(value)` for reliable NaN detection."]
-	} },
-	setup(context) {
-		return { visitors: { BinaryExpression: (node, { sourceFile, typeChecker }) => {
-			if (!comparisonOperators.has(node.operatorToken.kind)) return;
-			if (isNaNIdentifier(node.left, typeChecker) || isNaNIdentifier(node.right, typeChecker)) context.report({
-				message: "useIsNaN",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		} } };
-		function isNaNIdentifier(node, typeChecker) {
-			const unwrapped = unwrapParenthesizedNode(node);
-			return unwrapped.kind === SyntaxKind.Identifier && unwrapped.text === "NaN" && isGlobalDeclarationOfName(unwrapped, "NaN", typeChecker);
-		}
-	}
-});
-//#endregion
-export { isNaNComparisons_default as default };
-
-//# sourceMappingURL=isNaNComparisons.js.map

package/lib/rules/literalConstructorWrappers.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Prefers literal syntax over constructor function calls for primitive values.";
-    readonly id: "literalConstructorWrappers";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferLiteral", undefined>;
-export default _default;
-//# sourceMappingURL=literalConstructorWrappers.d.ts.map

package/lib/rules/literalConstructorWrappers.js

@@ -1,64 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/literalConstructorWrappers.ts
-const literalConstructors = new Set([
-	"BigInt",
-	"Boolean",
-	"Number",
-	"String"
-]);
-function isBooleanLiteral(node) {
-	return node.kind === ts$1.SyntaxKind.TrueKeyword || node.kind === ts$1.SyntaxKind.FalseKeyword;
-}
-function isLiteralArgument(node, constructorName) {
-	switch (constructorName) {
-		case "BigInt": return isNumericLiteralForBigInt(node);
-		case "Boolean": return ts$1.isLiteralExpression(node) || isBooleanLiteral(node);
-		case "Number": return ts$1.isStringLiteral(node) && isValidNumericString(node.text);
-		case "String": return ts$1.isNumericLiteral(node) || isBooleanLiteral(node) || ts$1.isBigIntLiteral(node);
-		default: return false;
-	}
-}
-function isNumericLiteralForBigInt(node) {
-	return node.kind === ts$1.SyntaxKind.NumericLiteral && /^-?\d+$/.test(node.text);
-}
-function isValidNumericString(value) {
-	const trimmed = value.trim();
-	if (trimmed === "") return false;
-	const number = Number(trimmed);
-	return !Number.isNaN(number) && Number.isFinite(number);
-}
-var literalConstructorWrappers_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Prefers literal syntax over constructor function calls for primitive values.",
-		id: "literalConstructorWrappers",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { preferLiteral: {
-		primary: "Prefer literal syntax over `{{ name }}()` for creating primitive values.",
-		secondary: ["Literal syntax like `123n` for BigInt or `!!value` for Boolean is more concise and idiomatic.", "Constructor calls can be replaced with operators or template literals."],
-		suggestions: ["Use literal syntax instead of `{{ name }}()`."]
-	} },
-	setup(context) {
-		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
-			if (!ts$1.isIdentifier(node.expression)) return;
-			const name = node.expression.text;
-			if (!literalConstructors.has(name) || node.arguments.length !== 1 || !isGlobalDeclarationOfName(node.expression, name, typeChecker)) return;
-			const argument = node.arguments[0];
-			if (!isLiteralArgument(argument, name)) return;
-			context.report({
-				data: { name },
-				message: "preferLiteral",
-				range: {
-					begin: node.getStart(sourceFile),
-					end: node.expression.getEnd()
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { literalConstructorWrappers_default as default };
-
-//# sourceMappingURL=literalConstructorWrappers.js.map

package/lib/rules/mathMethods.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Prefer modern Math methods over legacy patterns.";
-    readonly id: "mathMethods";
-    readonly presets: readonly ["stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferModernMath", undefined>;
-export default _default;
-//# sourceMappingURL=mathMethods.d.ts.map

package/lib/rules/mathMethods.js

@@ -1,128 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { skipParentheses } from "./utils/skipParentheses.js";
-import { getTSNodeRange, hasSameTokens, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/mathMethods.ts
-function checkLogDivideConstant(node, typeChecker, constantName, replacementMethod) {
-	if (node.operatorToken.kind !== SyntaxKind.SlashToken) return;
-	const left = skipParentheses(node.left);
-	const right = skipParentheses(node.right);
-	if (getMathMethodArgument(left, "log", typeChecker) && isMathProperty(right, constantName, typeChecker)) return {
-		description: `Math.log(…) / Math.${constantName}`,
-		replacement: `Math.${replacementMethod}(…)`
-	};
-}
-function checkLogTimesConstant(node, typeChecker, constantName, replacementMethod) {
-	if (node.operatorToken.kind !== SyntaxKind.AsteriskToken) return;
-	const left = skipParentheses(node.left);
-	const right = skipParentheses(node.right);
-	if (getMathMethodArgument(left, "log", typeChecker) && isMathProperty(right, constantName, typeChecker)) return {
-		description: `Math.log(…) * Math.${constantName}`,
-		replacement: `Math.${replacementMethod}(…)`
-	};
-	if (isMathProperty(left, constantName, typeChecker) && getMathMethodArgument(right, "log", typeChecker)) return {
-		description: `Math.${constantName} * Math.log(…)`,
-		replacement: `Math.${replacementMethod}(…)`
-	};
-}
-function flattenPlusExpression(node) {
-	const unwrapped = skipParentheses(node);
-	if (unwrapped.kind === SyntaxKind.BinaryExpression && unwrapped.operatorToken.kind === SyntaxKind.PlusToken) return [...flattenPlusExpression(unwrapped.left), ...flattenPlusExpression(unwrapped.right)];
-	return [unwrapped];
-}
-function getMathMethodArgument(node, methodName, typeChecker) {
-	if (node.kind !== SyntaxKind.CallExpression || node.questionDotToken || node.arguments.length !== 1) return false;
-	const argument = node.arguments[0];
-	if (argument.kind === SyntaxKind.SpreadElement || !isMathProperty(node.expression, methodName, typeChecker)) return;
-	return argument;
-}
-function isMathProperty(node, propertyName, typeChecker) {
-	return node.kind === SyntaxKind.PropertyAccessExpression && !node.questionDotToken && node.name.kind === SyntaxKind.Identifier && node.name.text === propertyName && node.expression.kind === SyntaxKind.Identifier && isGlobalDeclarationOfName(node.expression, "Math", typeChecker);
-}
-function isPowerTwoExpression(node, sourceFile) {
-	const unwrapped = skipParentheses(node);
-	if (unwrapped.kind !== SyntaxKind.BinaryExpression) return false;
-	if (unwrapped.operatorToken.kind === SyntaxKind.AsteriskToken) return hasSameTokens(unwrapped.left, unwrapped.right, sourceFile);
-	if (unwrapped.operatorToken.kind === SyntaxKind.AsteriskAsteriskToken) {
-		const right = skipParentheses(unwrapped.right);
-		return right.kind === SyntaxKind.NumericLiteral && right.text === "2";
-	}
-	return false;
-}
-var mathMethods_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Prefer modern Math methods over legacy patterns.",
-		id: "mathMethods",
-		presets: ["stylisticStrict"]
-	},
-	messages: { preferModernMath: {
-		primary: "Prefer `{{ replacement }}` over `{{ description }}`.",
-		secondary: ["Modern Math methods are clearer and more explicit about their purpose.", "These methods have been available since ES2015 and are well-supported in all modern environments."],
-		suggestions: ["Replace the legacy pattern with the modern Math method."]
-	} },
-	setup(context) {
-		return { visitors: {
-			BinaryExpression: (node, { sourceFile, typeChecker }) => {
-				for (const { constantName, replacementMethod } of [{
-					constantName: "LOG10E",
-					replacementMethod: "log10"
-				}, {
-					constantName: "LOG2E",
-					replacementMethod: "log2"
-				}]) {
-					const match = checkLogTimesConstant(node, typeChecker, constantName, replacementMethod);
-					if (match) {
-						context.report({
-							data: {
-								description: match.description,
-								replacement: match.replacement
-							},
-							message: "preferModernMath",
-							range: getTSNodeRange(node, sourceFile)
-						});
-						return;
-					}
-				}
-				for (const { constantName, replacementMethod } of [{
-					constantName: "LN10",
-					replacementMethod: "log10"
-				}, {
-					constantName: "LN2",
-					replacementMethod: "log2"
-				}]) {
-					const match = checkLogDivideConstant(node, typeChecker, constantName, replacementMethod);
-					if (match) {
-						context.report({
-							data: {
-								description: match.description,
-								replacement: match.replacement
-							},
-							message: "preferModernMath",
-							range: getTSNodeRange(node, sourceFile)
-						});
-						return;
-					}
-				}
-			},
-			CallExpression: (node, { sourceFile, typeChecker }) => {
-				const argument = getMathMethodArgument(node, "sqrt", typeChecker);
-				if (!argument) return;
-				const expressions = flattenPlusExpression(argument);
-				if (!expressions.every((expr) => isPowerTwoExpression(expr, sourceFile))) return;
-				const replacementMethod = expressions.length === 1 ? "abs" : "hypot";
-				context.report({
-					data: {
-						description: "Math.sqrt(…)",
-						replacement: `Math.${replacementMethod}(…)`
-					},
-					message: "preferModernMath",
-					range: getTSNodeRange(node, sourceFile)
-				});
-			}
-		} };
-	}
-});
-//#endregion
-export { mathMethods_default as default };
-
-//# sourceMappingURL=mathMethods.js.map

package/lib/rules/meaninglessVoidOperators.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using the void operator on expressions that are already void or undefined.";
-    readonly id: "meaninglessVoidOperators";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "meaninglessVoid", undefined>;
-export default _default;
-//# sourceMappingURL=meaninglessVoidOperators.d.ts.map

package/lib/rules/meaninglessVoidOperators.js

@@ -1,39 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-import * as tsutils from "ts-api-utils";
-//#region src/rules/meaninglessVoidOperators.ts
-function isVoidOrUndefinedType(type) {
-	return tsutils.isTypeFlagSet(type, ts.TypeFlags.Void | ts.TypeFlags.Undefined);
-}
-var meaninglessVoidOperators_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using the void operator on expressions that are already void or undefined.",
-		id: "meaninglessVoidOperators",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { meaninglessVoid: {
-		primary: "Using the `void` operator on a value of type `{{ type }}` does nothing.",
-		secondary: ["The `void` operator is meant to discard a return value and produce `undefined`.", "Applying `void` to a value that is already `void` or `undefined` has no effect."],
-		suggestions: ["Remove the `void` operator.", "If you need to explicitly return `undefined`, use the value directly."]
-	} },
-	setup(context) {
-		return { visitors: { VoidExpression: (node, { sourceFile, typeChecker }) => {
-			const argumentType = getConstrainedTypeAtLocation(node.expression, typeChecker);
-			if (!tsutils.unionConstituents(argumentType).every(isVoidOrUndefinedType)) return;
-			context.report({
-				data: { type: typeChecker.typeToString(argumentType) },
-				message: "meaninglessVoid",
-				range: {
-					begin: node.getStart(sourceFile),
-					end: node.getEnd()
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { meaninglessVoidOperators_default as default };
-
-//# sourceMappingURL=meaninglessVoidOperators.js.map

package/lib/rules/misleadingVoidExpressions.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Require expressions of type void to appear in statement position.";
-    readonly id: "misleadingVoidExpressions";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "voidExpressionArrow" | "voidExpressionReturn" | "voidExpressionValue", undefined>;
-export default _default;
-//# sourceMappingURL=misleadingVoidExpressions.d.ts.map

package/lib/rules/misleadingVoidExpressions.js

@@ -1,128 +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/misleadingVoidExpressions.ts
-function getParentFunction(node) {
-	let current = node.parent;
-	while (current) {
-		if (ts$1.isFunctionDeclaration(current) || ts$1.isFunctionExpression(current) || ts$1.isArrowFunction(current) || ts$1.isMethodDeclaration(current)) return current;
-		current = current.parent;
-	}
-}
-function isInValidPosition(node) {
-	if (ts$1.isExpressionStatement(node.parent)) return { valid: true };
-	if (ts$1.isBinaryExpression(node.parent) && node.parent.operatorToken.kind === ts$1.SyntaxKind.CommaToken) {
-		if (node.parent.right === node) return isInValidPosition(node.parent);
-		return { valid: true };
-	}
-	if (ts$1.isParenthesizedExpression(node.parent)) return isInValidPosition(node.parent);
-	if (ts$1.isConditionalExpression(node.parent) && (node.parent.whenTrue === node || node.parent.whenFalse === node)) return isInValidPosition(node.parent);
-	if (ts$1.isBinaryExpression(node.parent) && (node.parent.operatorToken.kind === ts$1.SyntaxKind.AmpersandAmpersandToken || node.parent.operatorToken.kind === ts$1.SyntaxKind.BarBarToken || node.parent.operatorToken.kind === ts$1.SyntaxKind.QuestionQuestionToken) && node.parent.right === node) return isInValidPosition(node.parent);
-	if (ts$1.isVoidExpression(node.parent)) return { valid: true };
-	if (ts$1.isArrowFunction(node.parent) && node.parent.body === node) return {
-		invalidAncestor: node.parent,
-		valid: false
-	};
-	if (ts$1.isReturnStatement(node.parent)) return {
-		invalidAncestor: node.parent,
-		valid: false
-	};
-	return {
-		invalidAncestor: node,
-		valid: false
-	};
-}
-function isVoidLike(type) {
-	return tsutils.isTypeFlagSet(type, ts$1.TypeFlags.VoidLike);
-}
-var misleadingVoidExpressions_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Require expressions of type void to appear in statement position.",
-		id: "misleadingVoidExpressions",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: {
-		voidExpressionArrow: {
-			primary: "Returning a void expression from an arrow function shorthand is misleading.",
-			secondary: ["Arrow function shorthand returns a value, but void expressions are meant to be ignored.", "This can confuse readers who expect a meaningful return value."],
-			suggestions: ["Add braces to the arrow function to make the void expression a statement."]
-		},
-		voidExpressionReturn: {
-			primary: "Returning a void expression from a function is misleading.",
-			secondary: ["Return statements imply a value is being returned, but void expressions have no meaningful value.", "This can confuse readers about the function's intent."],
-			suggestions: ["Move the void expression before the return statement.", "Remove the return keyword if this is the last statement."]
-		},
-		voidExpressionValue: {
-			primary: "Void expressions should not be used as values.",
-			secondary: ["A `void` expression evaluates to `undefined` but its intent is to be ignored.", "Using void expressions as values can lead to confusing code and potential bugs."],
-			suggestions: ["Move the void expression to its own statement.", "Wrap with `void` operator to indicate the value is intentionally ignored."]
-		}
-	},
-	setup(context) {
-		function checkVoidExpression(node, { sourceFile, typeChecker }) {
-			if (!isVoidLike(getConstrainedTypeAtLocation(node, typeChecker))) return;
-			const positionResult = isInValidPosition(node);
-			if (positionResult.valid) return;
-			const { invalidAncestor } = positionResult;
-			if (ts$1.isArrowFunction(invalidAncestor)) {
-				const arrowBodyText = sourceFile.text.slice(invalidAncestor.body.getStart(sourceFile), invalidAncestor.body.getEnd());
-				const nodeText = sourceFile.text.slice(node.getStart(sourceFile), node.getEnd());
-				context.report({
-					message: "voidExpressionArrow",
-					range: getTSNodeRange(node, sourceFile),
-					suggestions: [{
-						id: "addBraces",
-						range: getTSNodeRange(invalidAncestor.body, sourceFile),
-						text: `{ ${arrowBodyText}; }`
-					}, {
-						id: "wrapWithVoid",
-						range: getTSNodeRange(node, sourceFile),
-						text: `void ${nodeText}`
-					}]
-				});
-				return;
-			}
-			const nodeText = sourceFile.text.slice(node.getStart(sourceFile), node.getEnd());
-			const suggestionBase = {
-				id: "wrapWithVoid",
-				range: getTSNodeRange(node, sourceFile),
-				text: `void ${nodeText}`
-			};
-			if (!ts$1.isReturnStatement(invalidAncestor)) {
-				context.report({
-					message: "voidExpressionValue",
-					range: getTSNodeRange(node, sourceFile),
-					suggestions: [suggestionBase]
-				});
-				return;
-			}
-			const functionNode = getParentFunction(invalidAncestor);
-			const isLastStatement = functionNode && ts$1.isBlock(invalidAncestor.parent) && invalidAncestor.parent.parent === functionNode && invalidAncestor.parent.statements.at(-1) === invalidAncestor;
-			const returnValueText = invalidAncestor.expression ? sourceFile.text.slice(invalidAncestor.expression.getStart(sourceFile), invalidAncestor.expression.getEnd()) : "";
-			context.report({
-				message: "voidExpressionReturn",
-				range: getTSNodeRange(node, sourceFile),
-				suggestions: [isLastStatement ? {
-					id: "removeReturn",
-					range: getTSNodeRange(invalidAncestor, sourceFile),
-					text: `${returnValueText};`
-				} : {
-					id: "moveBeforeReturn",
-					range: getTSNodeRange(invalidAncestor, sourceFile),
-					text: `${returnValueText}; return;`
-				}, suggestionBase]
-			});
-		}
-		return { visitors: {
-			AwaitExpression: checkVoidExpression,
-			CallExpression: checkVoidExpression,
-			TaggedTemplateExpression: checkVoidExpression
-		} };
-	}
-});
-//#endregion
-export { misleadingVoidExpressions_default as default };
-
-//# sourceMappingURL=misleadingVoidExpressions.js.map

package/lib/rules/moduleSpecifierLists.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Require non-empty specifier lists in import and export statements.";
-    readonly id: "moduleSpecifierLists";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "emptyExportSpecifiers" | "emptyImportSpecifiers", undefined>;
-export default _default;
-//# sourceMappingURL=moduleSpecifierLists.d.ts.map

package/lib/rules/moduleSpecifierLists.js

@@ -1,92 +0,0 @@
-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