@flint.fyi/ts 0.20.0 → 0.22.0

package/lib/rules/unnecessaryEscapes.js

@@ -1,134 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/unnecessaryEscapes.ts
-const validEscapes = new Set([
-	"0",
-	"\"",
-	"'",
-	"\\",
-	"`",
-	"b",
-	"f",
-	"n",
-	"r",
-	"t",
-	"v"
-]);
-function findUnnecessaryEscapes(fullText, quoteCharacter) {
-	const escapes = [];
-	let startIndex = 1;
-	let endIndex = fullText.length - 1;
-	if (quoteCharacter === "`") {
-		if (fullText.endsWith("${")) endIndex = fullText.length - 2;
-		if (fullText.startsWith("}`")) startIndex = 2;
-	}
-	let index = startIndex;
-	while (index < endIndex) {
-		if (fullText[index] !== "\\") {
-			index += 1;
-			continue;
-		}
-		const nextCharacter = fullText[index + 1];
-		if (!nextCharacter || index + 1 >= endIndex) break;
-		if (validEscapes.has(nextCharacter)) {
-			index += 2;
-			continue;
-		}
-		switch (nextCharacter) {
-			case "c": {
-				const characterAfterC = fullText[index + 2];
-				if (characterAfterC && /[a-z]/i.test(characterAfterC)) {
-					index += 3;
-					continue;
-				}
-				break;
-			}
-			case "u": {
-				const afterU = fullText.slice(index + 2);
-				if (/^[\da-f]{4}/i.test(afterU)) {
-					index += 6;
-					continue;
-				}
-				if (afterU.startsWith("{")) {
-					const closeBrace = afterU.indexOf("}");
-					if (closeBrace > 1 && /^[\da-f]+$/i.test(afterU.slice(1, closeBrace))) {
-						index += 3 + closeBrace;
-						continue;
-					}
-				}
-				break;
-			}
-			case "x":
-				if (/^[\da-f]{2}/i.test(fullText.slice(index + 2, index + 4))) {
-					index += 4;
-					continue;
-				}
-				break;
-			default: if (/[1-9]/.test(nextCharacter)) {
-				index += 2;
-				continue;
-			}
-		}
-		if (nextCharacter !== quoteCharacter) escapes.push({
-			character: nextCharacter,
-			end: index + 2,
-			start: index
-		});
-		index += 2;
-	}
-	return escapes;
-}
-var unnecessaryEscapes_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports unnecessary escape sequences in string literals and template strings.",
-		id: "unnecessaryEscapes",
-		presets: ["stylistic"]
-	},
-	messages: { unnecessary: {
-		primary: "Unnecessary escape for character '{{ character }}'.",
-		secondary: ["This character does not require escaping in this context.", "Removing the backslash makes the code clearer without changing its meaning."],
-		suggestions: ["Remove the unnecessary backslash."]
-	} },
-	setup(context) {
-		function checkNode(node, { sourceFile }) {
-			const fullText = node.getText(sourceFile);
-			let quoteChar;
-			if (node.kind === ts.SyntaxKind.StringLiteral) quoteChar = fullText.startsWith("\"") ? "\"" : "'";
-			else quoteChar = "`";
-			const escapes = findUnnecessaryEscapes(fullText, quoteChar);
-			for (const escape of escapes) {
-				const nodeStart = node.getStart(sourceFile);
-				const escapeStart = nodeStart + escape.start;
-				const escapeEnd = nodeStart + escape.end;
-				context.report({
-					data: { character: escape.character },
-					fix: {
-						range: {
-							begin: escapeStart,
-							end: escapeStart + 1
-						},
-						text: ""
-					},
-					message: "unnecessary",
-					range: {
-						begin: escapeStart,
-						end: escapeEnd
-					}
-				});
-			}
-		}
-		return { visitors: {
-			NoSubstitutionTemplateLiteral: checkNode,
-			StringLiteral: checkNode,
-			TemplateExpression: (node, services) => {
-				checkNode(node.head, services);
-				for (const span of node.templateSpans) checkNode(span.literal, services);
-			}
-		} };
-	}
-});
-//#endregion
-export { unnecessaryEscapes_default as default };
-
-//# sourceMappingURL=unnecessaryEscapes.js.map

package/lib/rules/unnecessaryMathClamps.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports unnecessary Math.min and Math.max calls with constant arguments or incorrect clamping patterns.";
-    readonly id: "unnecessaryMathClamps";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "constantArguments" | "incorrectClampOrder", undefined>;
-export default _default;
-//# sourceMappingURL=unnecessaryMathClamps.d.ts.map

package/lib/rules/unnecessaryMathClamps.js

@@ -1,114 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage, unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/unnecessaryMathClamps.ts
-function extractNumericLiteral(node) {
-	const unwrapped = unwrapParenthesizedNode(node);
-	if (unwrapped.kind === SyntaxKind.NumericLiteral) return Number(unwrapped.text);
-	if (unwrapped.kind === SyntaxKind.PrefixUnaryExpression && unwrapped.operator === SyntaxKind.MinusToken && unwrapped.operand.kind === SyntaxKind.NumericLiteral) return -Number(unwrapped.operand.text);
-	if (unwrapped.kind === SyntaxKind.PrefixUnaryExpression && unwrapped.operator === SyntaxKind.PlusToken && unwrapped.operand.kind === SyntaxKind.NumericLiteral) return Number(unwrapped.operand.text);
-}
-function getMathMethodInfo(node, typeChecker) {
-	const unwrapped = unwrapParenthesizedNode(node);
-	if (unwrapped.kind !== SyntaxKind.CallExpression || unwrapped.questionDotToken || unwrapped.arguments.length < 1 || unwrapped.arguments.some((arg) => arg.kind === SyntaxKind.SpreadElement)) return;
-	if (isMathMethod(unwrapped.expression, "min", typeChecker)) return {
-		arguments: Array.from(unwrapped.arguments),
-		method: "min",
-		node: unwrapped
-	};
-	if (isMathMethod(unwrapped.expression, "max", typeChecker)) return {
-		arguments: Array.from(unwrapped.arguments),
-		method: "max",
-		node: unwrapped
-	};
-}
-function isMathMethod(node, methodName, typeChecker) {
-	return node.kind === SyntaxKind.PropertyAccessExpression && !node.questionDotToken && node.name.kind === SyntaxKind.Identifier && node.name.text === methodName && node.expression.kind === SyntaxKind.Identifier && isGlobalDeclarationOfName(node.expression, "Math", typeChecker);
-}
-var unnecessaryMathClamps_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports unnecessary Math.min and Math.max calls with constant arguments or incorrect clamping patterns.",
-		id: "unnecessaryMathClamps",
-		presets: ["logical"]
-	},
-	messages: {
-		constantArguments: {
-			primary: "This `Math.{{ method }}` with all constant arguments will always return `{{ result }}`.",
-			secondary: ["When all arguments to `Math.{{ method }}` are constants, the result is always the same value.", "You can replace this call with the constant `{{ result }}` directly."],
-			suggestions: ["Replace with the constant value `{{ result }}`."]
-		},
-		incorrectClampOrder: {
-			primary: "Incorrect clamping pattern: `Math.{{ outerMethod }}({{ min }}, Math.{{ innerMethod }}({{ max }}, x))` should be `Math.min({{ max }}, Math.max({{ min }}, x))`.",
-			secondary: ["To clamp a value between a minimum and maximum, use `Math.min(max, Math.max(min, value))`.", "The current pattern will not correctly constrain the value to the intended range."],
-			suggestions: ["Use the correct clamping pattern: `Math.min(max, Math.max(min, value))`."]
-		}
-	},
-	setup(context) {
-		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
-			const outerInfo = getMathMethodInfo(node, typeChecker);
-			if (!outerInfo) return;
-			const numericValues = [];
-			let allNumeric = true;
-			for (const arg of outerInfo.arguments) {
-				const value = extractNumericLiteral(arg);
-				if (value === void 0) {
-					allNumeric = false;
-					break;
-				}
-				numericValues.push(value);
-			}
-			if (allNumeric) {
-				const result = outerInfo.method === "min" ? Math.min(...numericValues) : Math.max(...numericValues);
-				context.report({
-					data: {
-						method: outerInfo.method,
-						result: String(result)
-					},
-					message: "constantArguments",
-					range: getTSNodeRange(node, sourceFile)
-				});
-				return;
-			}
-			if (outerInfo.arguments.length === 2) {
-				const firstArgument = outerInfo.arguments[0];
-				const secondArgument = outerInfo.arguments[1];
-				const innerInfo = getMathMethodInfo(secondArgument, typeChecker);
-				if (innerInfo && innerInfo.method !== outerInfo.method && innerInfo.arguments.length === 2) {
-					const innerFirstArg = innerInfo.arguments[0];
-					const innerSecondArg = innerInfo.arguments[1];
-					if (!innerFirstArg || !innerSecondArg) return;
-					const outerConstant = extractNumericLiteral(firstArgument);
-					const innerConstantFirst = extractNumericLiteral(innerFirstArg);
-					const innerConstantSecond = extractNumericLiteral(innerSecondArg);
-					if (outerInfo.method === "max" && innerInfo.method === "min" && outerConstant !== void 0 && innerConstantFirst !== void 0 && outerConstant < innerConstantFirst) {
-						context.report({
-							data: {
-								innerMethod: innerInfo.method,
-								max: String(innerConstantFirst),
-								min: String(outerConstant),
-								outerMethod: outerInfo.method
-							},
-							message: "incorrectClampOrder",
-							range: getTSNodeRange(node, sourceFile)
-						});
-						return;
-					}
-					if (outerInfo.method === "max" && innerInfo.method === "min" && outerConstant !== void 0 && innerConstantSecond !== void 0 && outerConstant < innerConstantSecond) context.report({
-						data: {
-							innerMethod: innerInfo.method,
-							max: String(innerConstantSecond),
-							min: String(outerConstant),
-							outerMethod: outerInfo.method
-						},
-						message: "incorrectClampOrder",
-						range: getTSNodeRange(node, sourceFile)
-					});
-				}
-			}
-		} } };
-	}
-});
-//#endregion
-export { unnecessaryMathClamps_default as default };
-
-//# sourceMappingURL=unnecessaryMathClamps.js.map

package/lib/rules/unnecessaryNumericFractions.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports numeric literals with unnecessary zero fractions or dangling dots.";
-    readonly id: "unnecessaryNumericFractions";
-    readonly presets: readonly ["stylistic"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "danglingDot" | "zeroFraction", undefined>;
-export default _default;
-//# sourceMappingURL=unnecessaryNumericFractions.d.ts.map

package/lib/rules/unnecessaryNumericFractions.js

@@ -1,50 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/unnecessaryNumericFractions.ts
-var unnecessaryNumericFractions_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports numeric literals with unnecessary zero fractions or dangling dots.",
-		id: "unnecessaryNumericFractions",
-		presets: ["stylistic"]
-	},
-	messages: {
-		danglingDot: {
-			primary: "Prefer `{{ fixed }}` over `{{ raw }}` to avoid a dangling dot.",
-			secondary: ["Numeric literals with dangling dots (e.g., `1.`) are harder to read and can be confusing.", "The dot doesn't add any precision information to the number."],
-			suggestions: ["Remove the dangling dot from the numeric literal."]
-		},
-		zeroFraction: {
-			primary: "Prefer `{{ fixed }}` over `{{ raw }}` to avoid an unnecessary zero fraction.",
-			secondary: ["Numeric literals with zero fractions (e.g., `1.0`) are unnecessarily verbose.", "The zero fraction doesn't add any precision information to the number."],
-			suggestions: ["Remove the zero fraction from the numeric literal."]
-		}
-	},
-	setup(context) {
-		return { visitors: { NumericLiteral: (node, { sourceFile }) => {
-			const raw = node.getText(sourceFile);
-			const match = /^([\d_]*)(\.[\d_]*)(?:e[+-]?\d+)?$/.exec(raw);
-			if (!match) return;
-			const before = match[1];
-			const dotAndFractions = match[2];
-			const after = raw.slice(before.length + dotAndFractions.length);
-			const fixed = (before + dotAndFractions.replace(/[0_]+$/, "").replace(/\.$/, "") || "0") + after;
-			if (fixed === raw) return;
-			context.report({
-				data: {
-					fixed,
-					raw
-				},
-				fix: {
-					range: getTSNodeRange(node, sourceFile),
-					text: fixed
-				},
-				message: dotAndFractions === "." ? "danglingDot" : "zeroFraction",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { unnecessaryNumericFractions_default as default };
-
-//# sourceMappingURL=unnecessaryNumericFractions.js.map

package/lib/rules/unnecessaryRenames.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Renames that don't change the identifier name are unnecessary.";
-    readonly id: "unnecessaryRenames";
-    readonly presets: readonly ["stylistic"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessaryRename", undefined>;
-export default _default;
-//# sourceMappingURL=unnecessaryRenames.d.ts.map

package/lib/rules/unnecessaryRenames.js

@@ -1,92 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { countCommentsInRange } from "./utils/countCommentsInRange.js";
-import { getTSNodeRange, typescriptLanguage, unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/unnecessaryRenames.ts
-function getModuleNameText(node) {
-	if (!node) return;
-	if (ts.isIdentifier(node) || ts.isStringLiteral(node)) return node.text;
-}
-function getPropertyAssignmentTargetInfo(node) {
-	if (node.initializer.kind === ts.SyntaxKind.BinaryExpression && node.initializer.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
-		const targetParent = node.initializer.left;
-		return {
-			parenthesizesTarget: targetParent.kind === ts.SyntaxKind.ParenthesizedExpression,
-			replacementNode: node.initializer,
-			targetNode: unwrapParenthesizedNode(targetParent)
-		};
-	}
-	const targetNode = unwrapParenthesizedNode(node.initializer);
-	return {
-		parenthesizesTarget: false,
-		replacementNode: targetNode,
-		targetNode
-	};
-}
-var unnecessaryRenames_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Renames that don't change the identifier name are unnecessary.",
-		id: "unnecessaryRenames",
-		presets: ["stylistic"]
-	},
-	messages: { unnecessaryRename: {
-		primary: "Renaming to the same identifier name is unnecessary.",
-		secondary: ["Using the same name for both the source and target is redundant.", "Remove the rename and use the shorthand syntax instead."],
-		suggestions: ["Remove the unnecessary rename."]
-	} },
-	setup(context) {
-		function reportUnnecessaryRename(node, parenthesizesTarget, replacementRange, sourceFile) {
-			const range = getTSNodeRange(node, sourceFile);
-			const shouldSkipFix = parenthesizesTarget || countCommentsInRange(sourceFile.text, range) > countCommentsInRange(sourceFile.text, replacementRange);
-			context.report({
-				fix: shouldSkipFix ? void 0 : {
-					range,
-					text: sourceFile.text.slice(replacementRange.begin, replacementRange.end)
-				},
-				message: "unnecessaryRename",
-				range
-			});
-		}
-		function checkExportOrImportSpecifier(original, rangeNode, sourceFile) {
-			if (getModuleNameText(original.propertyName) !== getModuleNameText(original.name)) return;
-			reportUnnecessaryRename(original, false, getTSNodeRange(rangeNode, sourceFile), sourceFile);
-		}
-		function checkObjectLiteralDestructuring(node, sourceFile) {
-			for (const property of node.properties) {
-				if (!ts.isPropertyAssignment(property) || property.name.kind === ts.SyntaxKind.ComputedPropertyName) continue;
-				const { parenthesizesTarget, replacementNode, targetNode } = getPropertyAssignmentTargetInfo(property);
-				if (ts.isObjectLiteralExpression(targetNode)) {
-					checkObjectLiteralDestructuring(targetNode, sourceFile);
-					continue;
-				}
-				if (targetNode.kind !== ts.SyntaxKind.Identifier) continue;
-				if (getModuleNameText(property.name) !== targetNode.text) continue;
-				reportUnnecessaryRename(property, parenthesizesTarget, getTSNodeRange(replacementNode, sourceFile), sourceFile);
-			}
-		}
-		return { visitors: {
-			BinaryExpression: (node, { sourceFile }) => {
-				if (node.operatorToken.kind !== ts.SyntaxKind.EqualsToken) return;
-				const left = unwrapParenthesizedNode(node.left);
-				if (left.kind !== ts.SyntaxKind.ObjectLiteralExpression) return;
-				checkObjectLiteralDestructuring(left, sourceFile);
-			},
-			BindingElement: (node, { sourceFile }) => {
-				if (node.propertyName?.kind !== ts.SyntaxKind.ComputedPropertyName && node.name.kind === ts.SyntaxKind.Identifier && getModuleNameText(node.propertyName) === getModuleNameText(node.name)) reportUnnecessaryRename(node, false, {
-					begin: node.name.getStart(sourceFile),
-					end: node.getEnd()
-				}, sourceFile);
-			},
-			ExportSpecifier: (node, { sourceFile }) => {
-				if (node.propertyName) checkExportOrImportSpecifier(node, node.propertyName, sourceFile);
-			},
-			ImportSpecifier: (node, { sourceFile }) => {
-				checkExportOrImportSpecifier(node, node.name, sourceFile);
-			}
-		} };
-	}
-});
-//#endregion
-export { unnecessaryRenames_default as default };
-
-//# sourceMappingURL=unnecessaryRenames.js.map

package/lib/rules/unnecessaryTernaries.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports ternary expressions that can be simplified to boolean expressions or logical operators";
-    readonly id: "unnecessaryTernaries";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessaryBooleanTernary" | "unnecessaryLogicalTernary", undefined>;
-export default _default;
-//# sourceMappingURL=unnecessaryTernaries.d.ts.map

package/lib/rules/unnecessaryTernaries.js

@@ -1,88 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, hasSameTokens, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/unnecessaryTernaries.ts
-function getNodeText(node, sourceFile) {
-	return sourceFile.text.slice(node.getStart(sourceFile), node.getEnd());
-}
-var unnecessaryTernaries_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports ternary expressions that can be simplified to boolean expressions or logical operators",
-		id: "unnecessaryTernaries",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: {
-		unnecessaryBooleanTernary: {
-			primary: "This ternary expression can be simplified to a boolean expression.",
-			secondary: ["Using a ternary to return true or false based on a condition is redundant.", "The condition itself already evaluates to a boolean value."],
-			suggestions: ["Simplify to a boolean expression."]
-		},
-		unnecessaryLogicalTernary: {
-			primary: "This ternary expression can be simplified to a logical operator.",
-			secondary: ["Using a ternary where the consequent matches the condition is redundant.", "A logical OR operator (`||`) expresses the same logic more clearly."],
-			suggestions: ["Replace with logical OR operator."]
-		}
-	},
-	setup(context) {
-		return { visitors: { ConditionalExpression(node, { sourceFile }) {
-			const { condition, whenFalse, whenTrue } = node;
-			if (whenTrue.kind === ts.SyntaxKind.TrueKeyword && whenFalse.kind === ts.SyntaxKind.FalseKeyword) {
-				const range = getTSNodeRange(node, sourceFile);
-				context.report({
-					fix: {
-						range,
-						text: getNodeText(condition, sourceFile)
-					},
-					message: "unnecessaryBooleanTernary",
-					range
-				});
-				return;
-			}
-			if (whenTrue.kind === ts.SyntaxKind.FalseKeyword && whenFalse.kind === ts.SyntaxKind.TrueKeyword) {
-				const range = getTSNodeRange(node, sourceFile);
-				const conditionText = getNodeText(condition, sourceFile);
-				const negatedCondition = ts.isBinaryExpression(condition) || ts.isConditionalExpression(condition) ? `!(${conditionText})` : `!${conditionText}`;
-				context.report({
-					fix: {
-						range,
-						text: negatedCondition
-					},
-					message: "unnecessaryBooleanTernary",
-					range
-				});
-				return;
-			}
-			if (hasSameTokens(condition, whenTrue, sourceFile)) {
-				const range = getTSNodeRange(node, sourceFile);
-				const conditionText = getNodeText(condition, sourceFile);
-				const alternateText = getNodeText(whenFalse, sourceFile);
-				context.report({
-					fix: {
-						range,
-						text: `${conditionText} || ${alternateText}`
-					},
-					message: "unnecessaryLogicalTernary",
-					range
-				});
-				return;
-			}
-			if (ts.isPrefixUnaryExpression(condition) && condition.operator === ts.SyntaxKind.ExclamationToken && hasSameTokens(condition.operand, whenFalse, sourceFile)) {
-				const range = getTSNodeRange(node, sourceFile);
-				const operandText = getNodeText(condition.operand, sourceFile);
-				const alternateText = getNodeText(whenTrue, sourceFile);
-				context.report({
-					fix: {
-						range,
-						text: `${operandText} || ${alternateText}`
-					},
-					message: "unnecessaryLogicalTernary",
-					range
-				});
-			}
-		} } };
-	}
-});
-//#endregion
-export { unnecessaryTernaries_default as default };
-
-//# sourceMappingURL=unnecessaryTernaries.js.map

package/lib/rules/unnecessaryUseStricts.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports unnecessary \"use strict\" directives in ES modules and classes.";
-    readonly id: "unnecessaryUseStricts";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessaryUseStrict", undefined>;
-export default _default;
-//# sourceMappingURL=unnecessaryUseStricts.d.ts.map

package/lib/rules/unnecessaryUseStricts.js

@@ -1,40 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/unnecessaryUseStricts.ts
-var unnecessaryUseStricts_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports unnecessary \"use strict\" directives in ES modules and classes.",
-		id: "unnecessaryUseStricts",
-		presets: ["logical"]
-	},
-	messages: { unnecessaryUseStrict: {
-		primary: "This `\"use strict\"` directive is redundant and can be safely removed.",
-		secondary: ["ECMAScript modules and class bodies are automatically in strict mode.", "The `\"use strict\"` directive has no effect and is redundant."],
-		suggestions: ["Remove the `\"use strict\"` directive."]
-	} },
-	setup(context) {
-		return { visitors: { SourceFile(node, { sourceFile }) {
-			if (!ts.isExternalModule(sourceFile)) return;
-			const firstStatement = node.statements[0];
-			if (!ts.isExpressionStatement(firstStatement) || !ts.isStringLiteral(firstStatement.expression) || firstStatement.expression.text !== "use strict") return;
-			const secondStatement = node.statements[1];
-			const fixEnd = secondStatement ? secondStatement.getStart(sourceFile) : firstStatement.getEnd();
-			context.report({
-				fix: {
-					range: {
-						begin: firstStatement.getStart(sourceFile),
-						end: fixEnd
-					},
-					text: ""
-				},
-				message: "unnecessaryUseStrict",
-				range: getTSNodeRange(firstStatement, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { unnecessaryUseStricts_default as default };
-
-//# sourceMappingURL=unnecessaryUseStricts.js.map

package/lib/rules/unsafeNegations.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports negating the left operand of `in` or `instanceof` relations.";
-    readonly id: "unsafeNegations";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferNegatingRelation", undefined>;
-export default _default;
-//# sourceMappingURL=unsafeNegations.d.ts.map

package/lib/rules/unsafeNegations.js

@@ -1,38 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage, unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/unsafeNegations.ts
-const operatorStrings = new Map([[SyntaxKind.InKeyword, "in"], [SyntaxKind.InstanceOfKeyword, "instanceof"]]);
-var unsafeNegations_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports negating the left operand of `in` or `instanceof` relations.",
-		id: "unsafeNegations",
-		presets: ["javascript"]
-	},
-	messages: { preferNegatingRelation: {
-		primary: "This negation applies before the `{{ operator }}` operator.",
-		secondary: ["The logical not operator (!) has higher precedence than `in` and `instanceof`.", "Write `!(left in right)` or `!(left instanceof Right)` to negate the relation as intended."],
-		suggestions: ["Wrap the relation in parentheses and negate it."]
-	} },
-	setup(context) {
-		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
-			const operator = operatorStrings.get(node.operatorToken.kind);
-			if (!operator) return;
-			const left = unwrapParenthesizedNode(node.left);
-			if (left.kind !== SyntaxKind.PrefixUnaryExpression || left.operator !== SyntaxKind.ExclamationToken) return;
-			const begin = left.getStart(sourceFile);
-			context.report({
-				data: { operator },
-				message: "preferNegatingRelation",
-				range: {
-					begin,
-					end: begin + 1
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { unsafeNegations_default as default };
-
-//# sourceMappingURL=unsafeNegations.js.map

package/lib/rules/utils/collectAccessorPairs.d.ts

@@ -1,12 +0,0 @@
-import ts from "typescript";
-import type { AST } from "@flint.fyi/typescript-language";
-export interface AccessorInfo {
-    index: number;
-    node: AST.GetAccessorDeclaration | AST.SetAccessorDeclaration;
-}
-export interface AccessorPair {
-    getter?: AccessorInfo;
-    setter?: AccessorInfo;
-}
-export declare function collectAccessorPairs(members: ts.NodeArray<AST.AnyNode>, sourceFile: AST.SourceFile): Map<string, AccessorPair>;
-//# sourceMappingURL=collectAccessorPairs.d.ts.map

package/lib/rules/utils/collectAccessorPairs.js

@@ -1,29 +0,0 @@
-import ts from "typescript";
-//#region src/rules/utils/collectAccessorPairs.ts
-function collectAccessorPairs(members, sourceFile) {
-	const pairs = /* @__PURE__ */ new Map();
-	members.forEach((member, index) => {
-		if (member.kind !== ts.SyntaxKind.GetAccessor && member.kind !== ts.SyntaxKind.SetAccessor) return;
-		const name = getPropertyName(member, sourceFile);
-		let pair = pairs.get(name);
-		if (!pair) {
-			pair = {};
-			pairs.set(name, pair);
-		}
-		const entry = {
-			index,
-			node: member
-		};
-		if (member.kind === ts.SyntaxKind.GetAccessor) pair.getter = entry;
-		else pair.setter = entry;
-	});
-	return pairs;
-}
-function getPropertyName(accessor, sourceFile) {
-	if (ts.isIdentifier(accessor.name) || ts.isStringLiteral(accessor.name) || ts.isNumericLiteral(accessor.name)) return accessor.name.text;
-	return accessor.name.getText(sourceFile);
-}
-//#endregion
-export { collectAccessorPairs };
-
-//# sourceMappingURL=collectAccessorPairs.js.map