@flint.fyi/ts 0.21.0 → 0.22.0

package/lib/rules/utils/formatReportedType.js

@@ -1,7 +0,0 @@
-import * as tsutils from "ts-api-utils";
-//#region src/rules/utils/formatReportedType.ts
-function formatReportedType(type, typeChecker) {
-	return tsutils.isIntrinsicErrorType(type) ? "error" : typeChecker.typeToString(type);
-}
-//#endregion
-export { formatReportedType };

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

@@ -1,2 +0,0 @@
-import type { AST, Checker } from "@flint.fyi/typescript-language";
-export declare function getConstrainedTypeAtLocation(node: AST.Expression, typeChecker: Checker): import("typescript").Type;

package/lib/rules/utils/getConstrainedType.js

@@ -1,7 +0,0 @@
-//#region src/rules/utils/getConstrainedType.ts
-function getConstrainedTypeAtLocation(node, typeChecker) {
-	const type = typeChecker.getTypeAtLocation(node);
-	return typeChecker.getBaseConstraintOfType(type) ?? type;
-}
-//#endregion
-export { getConstrainedTypeAtLocation };

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

@@ -1,2 +0,0 @@
-import type { AST } from "@flint.fyi/typescript-language";
-export declare function getFunctionName(node: AST.ArrowFunction | AST.FunctionDeclaration | AST.FunctionExpression | AST.MethodDeclaration | AST.MethodSignature): string | undefined;

package/lib/rules/utils/getFunctionName.js

@@ -1,14 +0,0 @@
-import ts from "typescript";
-//#region src/rules/utils/getFunctionName.ts
-function getFunctionName(node) {
-	switch (node.kind) {
-		case ts.SyntaxKind.ArrowFunction: return ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name) ? node.parent.name.text : void 0;
-		case ts.SyntaxKind.FunctionDeclaration:
-		case ts.SyntaxKind.FunctionExpression: return node.name?.text;
-		case ts.SyntaxKind.MethodDeclaration:
-		case ts.SyntaxKind.MethodSignature: return ts.isIdentifier(node.name) ? node.name.text : void 0;
-		default: return;
-	}
-}
-//#endregion
-export { getFunctionName };

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

@@ -1,8 +0,0 @@
-import { type AST, type TypeScriptFileServices } from "@flint.fyi/typescript-language";
-export declare function getRegExpConstruction(node: AST.CallExpression | AST.NewExpression, { program, sourceFile, typeChecker }: TypeScriptFileServices): {
-    args: import("typescript").NodeArray<AST.Expression>;
-    flags: string;
-    pattern: string;
-    raw: string;
-    start: number;
-} | undefined;

package/lib/rules/utils/getRegExpConstruction.js

@@ -1,25 +0,0 @@
-import { getStaticStringValue, isGlobalDeclarationOfName } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/utils/getRegExpConstruction.ts
-function getRegExpConstruction(node, { program, sourceFile, typeChecker }) {
-	if (node.expression.kind !== SyntaxKind.Identifier || node.expression.text !== "RegExp" || !isGlobalDeclarationOfName(node.expression, "RegExp", typeChecker, program)) return;
-	const args = node.arguments;
-	if (!args?.length) return;
-	const firstArgument = args[0];
-	if (firstArgument.kind !== SyntaxKind.StringLiteral && firstArgument.kind !== SyntaxKind.NoSubstitutionTemplateLiteral) return;
-	let flags = "";
-	if (args.length >= 2) {
-		const flagsArg = args[1];
-		const flagsValue = flagsArg === void 0 ? void 0 : getStaticStringValue(flagsArg);
-		if (flagsValue !== void 0) flags = flagsValue;
-	}
-	return {
-		args,
-		flags,
-		pattern: firstArgument.getText(sourceFile).slice(1, -1),
-		raw: firstArgument.text,
-		start: firstArgument.getStart(sourceFile)
-	};
-}
-//#endregion
-export { getRegExpConstruction };

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

@@ -1,6 +0,0 @@
-import type { AST, TypeScriptFileServices } from "@flint.fyi/typescript-language";
-export declare function getRegExpLiteralDetails(node: AST.RegularExpressionLiteral, { sourceFile }: Pick<TypeScriptFileServices, "sourceFile">): {
-    flags: string;
-    pattern: string;
-    start: number;
-};

package/lib/rules/utils/getRegExpLiteralDetails.js

@@ -1,11 +0,0 @@
-//#region src/rules/utils/getRegExpLiteralDetails.ts
-function getRegExpLiteralDetails(node, { sourceFile }) {
-	const lastSlash = node.text.lastIndexOf("/");
-	return {
-		flags: node.text.slice(lastSlash + 1),
-		pattern: node.text.slice(1, lastSlash),
-		start: node.getStart(sourceFile) + 1
-	};
-}
-//#endregion
-export { getRegExpLiteralDetails };

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

@@ -1,2 +0,0 @@
-import type { AST } from "@flint.fyi/typescript-language";
-export declare function getThisExpression(node: AST.Expression): AST.ThisExpression | null;

package/lib/rules/utils/getThisExpression.js

@@ -1,14 +0,0 @@
-import { skipParentheses } from "./skipParentheses.js";
-import { SyntaxKind } from "typescript";
-//#region src/rules/utils/getThisExpression.ts
-function getThisExpression(node) {
-	while (true) {
-		node = skipParentheses(node);
-		if (node.kind === SyntaxKind.CallExpression || node.kind === SyntaxKind.PropertyAccessExpression || node.kind === SyntaxKind.ElementAccessExpression) node = node.expression;
-		else if (node.kind === SyntaxKind.ThisKeyword) return node;
-		else break;
-	}
-	return null;
-}
-//#endregion
-export { getThisExpression };

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

@@ -1,2 +0,0 @@
-import type { AST, Checker } from "@flint.fyi/typescript-language";
-export declare function isArrayOrTupleTypeAtLocation(node: AST.Expression, typeChecker: Checker): boolean;

package/lib/rules/utils/isArrayOrTupleTypeAtLocation.js

@@ -1,11 +0,0 @@
-import { getConstrainedTypeAtLocation } from "./getConstrainedType.js";
-import { isTypeRecursive } from "./isTypeRecursive.js";
-//#region src/rules/utils/isArrayOrTupleTypeAtLocation.ts
-function isArrayOrTupleTypeAtLocation(node, typeChecker) {
-	return isArrayOrTupleType(getConstrainedTypeAtLocation(node, typeChecker), typeChecker);
-}
-function isArrayOrTupleType(type, typeChecker) {
-	return isTypeRecursive(type, (constituent) => typeChecker.isArrayType(constituent) || typeChecker.isTupleType(constituent));
-}
-//#endregion
-export { isArrayOrTupleTypeAtLocation };

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

@@ -1,2 +0,0 @@
-import * as ts from "typescript";
-export declare function isBuiltinSymbolLike(program: ts.Program, type: ts.Type, symbolName: string): boolean;

package/lib/rules/utils/isBuiltinSymbolLike.js

@@ -1,31 +0,0 @@
-import * as ts$1 from "typescript";
-import * as tsutils from "ts-api-utils";
-//#region src/rules/utils/isBuiltinSymbolLike.ts
-function isBuiltinSymbolLike(program, type, symbolName) {
-	return isBuiltinSymbolLikeRecurser(program, type, (subType) => {
-		const symbol = subType.getSymbol();
-		if (!symbol) return false;
-		const actualSymbolName = symbol.getName();
-		if (actualSymbolName === symbolName && isSymbolFromDefaultLibrary(program, symbol)) return true;
-		if (actualSymbolName === "Function" && tsutils.isObjectType(subType) && tsutils.isObjectFlagSet(subType, ts$1.ObjectFlags.Anonymous)) return false;
-		return null;
-	});
-}
-function isBuiltinSymbolLikeRecurser(program, type, predicate) {
-	if (type.isUnionOrIntersection()) return type.types.some((subType) => isBuiltinSymbolLikeRecurser(program, subType, predicate));
-	const result = predicate(type);
-	if (result !== null) return result;
-	const bases = type.getBaseTypes();
-	if (bases?.length) return bases.some((baseType) => isBuiltinSymbolLikeRecurser(program, baseType, predicate));
-	return false;
-}
-function isSymbolFromDefaultLibrary(program, symbol) {
-	const declarations = symbol.getDeclarations();
-	if (!declarations?.length) return false;
-	return declarations.some((declaration) => {
-		const sourceFile = declaration.getSourceFile();
-		return program.isSourceFileDefaultLibrary(sourceFile);
-	});
-}
-//#endregion
-export { isBuiltinSymbolLike };

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

@@ -1,3 +0,0 @@
-import * as ts from "typescript";
-import type { AST } from "@flint.fyi/typescript-language";
-export declare function isDirectEqualityCheck(node: AST.ArrowFunction | AST.FunctionExpression, operators: ts.SyntaxKind[], parameterName: string): AST.Expression | undefined;

package/lib/rules/utils/isDirectEqualityCheck.js

@@ -1,27 +0,0 @@
-import * as ts$1 from "typescript";
-//#region src/rules/utils/isDirectEqualityCheck.ts
-function isDirectEqualityCheck(node, operators, parameterName) {
-	let body;
-	switch (node.kind) {
-		case ts$1.SyntaxKind.ArrowFunction:
-			body = node.body.kind === ts$1.SyntaxKind.Block ? getDirectReturnExpression(node.body) : node.body;
-			break;
-		case ts$1.SyntaxKind.FunctionExpression:
-			body = getDirectReturnExpression(node.body);
-			break;
-	}
-	if (!body || !ts$1.isBinaryExpression(body)) return;
-	const { left, operatorToken, right } = body;
-	if (!operators.includes(operatorToken.kind)) return;
-	const isLeftParam = ts$1.isIdentifier(left) && left.text === parameterName;
-	const isRightParam = ts$1.isIdentifier(right) && right.text === parameterName;
-	if (isLeftParam && !isRightParam) return right;
-	if (isRightParam && !isLeftParam) return left;
-}
-function getDirectReturnExpression(body) {
-	if (body.statements.length !== 1) return;
-	const statement = body.statements[0];
-	return statement.kind === ts$1.SyntaxKind.ReturnStatement ? statement.expression : void 0;
-}
-//#endregion
-export { isDirectEqualityCheck };

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

@@ -1,3 +0,0 @@
-import { type Program } from "typescript";
-import { type AST, type Checker } from "@flint.fyi/typescript-language";
-export declare function isErrorSubclass(node: AST.ClassDeclaration, typeChecker: Checker, program: Program): boolean;

package/lib/rules/utils/isErrorSubclass.js

@@ -1,25 +0,0 @@
-import { isGlobalDeclaration } from "@flint.fyi/typescript-language";
-import { SyntaxKind, isIdentifier } from "typescript";
-//#region src/rules/utils/isErrorSubclass.ts
-const builtinErrorNames = /* @__PURE__ */ new Set([
-	"Error",
-	"EvalError",
-	"RangeError",
-	"ReferenceError",
-	"SyntaxError",
-	"TypeError",
-	"URIError"
-]);
-function isErrorSubclass(node, typeChecker, program) {
-	if (!node.heritageClauses) return false;
-	for (const clause of node.heritageClauses) {
-		if (clause.token !== SyntaxKind.ExtendsKeyword) continue;
-		for (const type of clause.types) {
-			const typeName = type.expression;
-			if (isIdentifier(typeName) && builtinErrorNames.has(typeName.text) && isGlobalDeclaration(typeName, typeChecker, program)) return true;
-		}
-	}
-	return false;
-}
-//#endregion
-export { isErrorSubclass };

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

@@ -1,2 +0,0 @@
-import type { AST } from "@flint.fyi/typescript-language";
-export declare function isInBooleanContext(node: AST.AnyNode): boolean;

package/lib/rules/utils/isInBooleanContext.js

@@ -1,20 +0,0 @@
-import ts from "typescript";
-//#region src/rules/utils/isInBooleanContext.ts
-function isInBooleanContext(node) {
-	switch (node.parent.kind) {
-		case ts.SyntaxKind.AsExpression:
-		case ts.SyntaxKind.NonNullExpression:
-		case ts.SyntaxKind.ParenthesizedExpression: return isInBooleanContext(node.parent);
-		case ts.SyntaxKind.BinaryExpression: return node.parent.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken || node.parent.operatorToken.kind === ts.SyntaxKind.BarBarToken;
-		case ts.SyntaxKind.CallExpression: return ts.isIdentifier(node.parent.expression) && node.parent.expression.text === "Boolean" && node.parent.arguments.length === 1 && node.parent.arguments[0] === node;
-		case ts.SyntaxKind.ConditionalExpression:
-		case ts.SyntaxKind.ForStatement: return node.parent.condition === node;
-		case ts.SyntaxKind.DoStatement:
-		case ts.SyntaxKind.IfStatement:
-		case ts.SyntaxKind.WhileStatement: return node.parent.expression === node;
-		case ts.SyntaxKind.PrefixUnaryExpression: return node.parent.operator === ts.SyntaxKind.ExclamationToken;
-		default: return false;
-	}
-}
-//#endregion
-export { isInBooleanContext };

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

@@ -1,2 +0,0 @@
-import type * as ts from "typescript";
-export declare function isTypeRecursive(type: ts.Type, predicate: (t: ts.Type) => boolean): boolean;

package/lib/rules/utils/isTypeRecursive.js

@@ -1,6 +0,0 @@
-//#region src/rules/utils/isTypeRecursive.ts
-function isTypeRecursive(type, predicate) {
-	return type.isUnionOrIntersection() ? type.types.some((subType) => isTypeRecursive(subType, predicate)) : predicate(type);
-}
-//#endregion
-export { isTypeRecursive };

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

@@ -1,14 +0,0 @@
-import ts from "typescript";
-import type { AST } from "@flint.fyi/typescript-language";
-/**
- * Does a simple check to see if there is an any being assigned to a non-any type.
- *
- * This also checks generic positions to ensure there's no unsafe sub-assignments.
- * Note: in the case of generic positions, it makes the assumption that the two types are the same.
- * @example See tests for examples
- * @returns false if it's safe, or an object with the two types if it's unsafe
- */
-export declare function isUnsafeAssignment(type: ts.Type, receiver: ts.Type, senderNode: AST.Expression): false | {
-    receiver: ts.Type;
-    sender: ts.Type;
-};

package/lib/rules/utils/isUnsafeAssignment.js

@@ -1,43 +0,0 @@
-import ts, { SyntaxKind } from "typescript";
-import * as tsutils from "ts-api-utils";
-import { nullThrows } from "@flint.fyi/utils";
-//#region src/rules/utils/isUnsafeAssignment.ts
-/**
-* Does a simple check to see if there is an any being assigned to a non-any type.
-*
-* This also checks generic positions to ensure there's no unsafe sub-assignments.
-* Note: in the case of generic positions, it makes the assumption that the two types are the same.
-* @example See tests for examples
-* @returns false if it's safe, or an object with the two types if it's unsafe
-*/
-function isUnsafeAssignment(type, receiver, senderNode) {
-	return isUnsafeAssignmentWorker(type, receiver, senderNode, /* @__PURE__ */ new Map());
-}
-function isUnsafeAssignmentWorker(type, receiver, senderNode, visited) {
-	if (tsutils.isTypeFlagSet(type, ts.TypeFlags.Any)) {
-		if (tsutils.isTypeFlagSet(receiver, ts.TypeFlags.Unknown)) return false;
-		if (!tsutils.isTypeFlagSet(receiver, ts.TypeFlags.Any)) return {
-			receiver,
-			sender: type
-		};
-	}
-	const typeAlreadyVisited = visited.get(type);
-	if (typeAlreadyVisited) {
-		if (typeAlreadyVisited.has(receiver)) return false;
-		typeAlreadyVisited.add(receiver);
-	} else visited.set(type, /* @__PURE__ */ new Set([receiver]));
-	if (tsutils.isTypeReference(type) && tsutils.isTypeReference(receiver)) {
-		if (type.target !== receiver.target) return false;
-		if (senderNode.kind === SyntaxKind.NewExpression && senderNode.expression.kind === SyntaxKind.Identifier && senderNode.expression.text === "Map" && !senderNode.arguments?.length && senderNode.typeArguments == null) return false;
-		const typeArguments = type.typeArguments ?? [];
-		const receiverTypeArguments = receiver.typeArguments ?? [];
-		for (let i = 0; i < typeArguments.length; i += 1) if (isUnsafeAssignmentWorker(nullThrows(typeArguments[i], "Type argument is expected to be present by the loop condition"), nullThrows(receiverTypeArguments[i], "Receiver type should have the same number of type arguments as the sender type when they share the same target"), senderNode, visited)) return {
-			receiver,
-			sender: type
-		};
-		return false;
-	}
-	return false;
-}
-//#endregion
-export { isUnsafeAssignment };

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

@@ -1,4 +0,0 @@
-import type { AST } from "@flint.fyi/typescript-language";
-export declare function isComparisonOperator(token: AST.BinaryOperatorToken): boolean;
-export declare function isEqualityOperator(token: AST.BinaryOperatorToken): boolean;
-export declare function isNegatedEqualityOperator(token: AST.BinaryOperatorToken): boolean;

package/lib/rules/utils/operators.js

@@ -1,33 +0,0 @@
-import { SyntaxKind } from "typescript";
-//#region src/rules/utils/operators.ts
-function isComparisonOperator(token) {
-	switch (token.kind) {
-		case SyntaxKind.EqualsEqualsEqualsToken:
-		case SyntaxKind.EqualsEqualsToken:
-		case SyntaxKind.ExclamationEqualsEqualsToken:
-		case SyntaxKind.ExclamationEqualsToken:
-		case SyntaxKind.GreaterThanEqualsToken:
-		case SyntaxKind.GreaterThanToken:
-		case SyntaxKind.LessThanEqualsToken:
-		case SyntaxKind.LessThanToken: return true;
-		default: return false;
-	}
-}
-function isEqualityOperator(token) {
-	switch (token.kind) {
-		case SyntaxKind.EqualsEqualsEqualsToken:
-		case SyntaxKind.EqualsEqualsToken:
-		case SyntaxKind.ExclamationEqualsEqualsToken:
-		case SyntaxKind.ExclamationEqualsToken: return true;
-		default: return false;
-	}
-}
-function isNegatedEqualityOperator(token) {
-	switch (token.kind) {
-		case SyntaxKind.ExclamationEqualsEqualsToken:
-		case SyntaxKind.ExclamationEqualsToken: return true;
-		default: return false;
-	}
-}
-//#endregion
-export { isComparisonOperator, isEqualityOperator, isNegatedEqualityOperator };

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

@@ -1 +0,0 @@
-export declare function parseRegexpAst(pattern: string, flags?: string): import("@eslint-community/regexpp/ast").Pattern | undefined;

package/lib/rules/utils/parseRegexpAst.js

@@ -1,15 +0,0 @@
-import { RegExpParser } from "@eslint-community/regexpp";
-//#region src/rules/utils/parseRegexpAst.ts
-const parser = new RegExpParser();
-function parseRegexpAst(pattern, flags = "") {
-	try {
-		return parser.parsePattern(pattern, void 0, void 0, {
-			unicode: flags.includes("u"),
-			unicodeSets: flags.includes("v")
-		});
-	} catch {
-		return;
-	}
-}
-//#endregion
-export { parseRegexpAst };

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

@@ -1,2 +0,0 @@
-import type { ParsedLiteral } from "scslre";
-export declare function parseRegexpAstFull(pattern: string, flags?: string): ParsedLiteral | undefined;

package/lib/rules/utils/parseRegexpAstFull.js

@@ -1,16 +0,0 @@
-import { RegExpParser } from "@eslint-community/regexpp";
-//#region src/rules/utils/parseRegexpAstFull.ts
-const parser = new RegExpParser();
-function parseRegexpAstFull(pattern, flags = "") {
-	try {
-		const regexpFlags = parser.parseFlags(flags);
-		return {
-			flags: regexpFlags,
-			pattern: parser.parsePattern(pattern, void 0, void 0, regexpFlags)
-		};
-	} catch {
-		return;
-	}
-}
-//#endregion
-export { parseRegexpAstFull };

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

@@ -1,2 +0,0 @@
-import type { AST } from "@flint.fyi/typescript-language";
-export declare function skipParentheses(node: AST.Expression): AST.Expression;

package/lib/rules/utils/skipParentheses.js

@@ -1,8 +0,0 @@
-import { SyntaxKind } from "typescript";
-//#region src/rules/utils/skipParentheses.ts
-function skipParentheses(node) {
-	while (node.kind === SyntaxKind.ParenthesizedExpression) node = node.expression;
-	return node;
-}
-//#endregion
-export { skipParentheses };

package/lib/rules/variableDeletions.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports attempting to delete variables with the delete operator.";
-    readonly id: "variableDeletions";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noDeleteVar", undefined>;
-export default _default;

package/lib/rules/variableDeletions.js

@@ -1,33 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/variableDeletions.ts
-var variableDeletions_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports attempting to delete variables with the delete operator.",
-		id: "variableDeletions",
-		presets: ["javascript"]
-	},
-	messages: { noDeleteVar: {
-		primary: "Deleting a variable with the delete operator outside of strict mode will silently fail and return false.",
-		secondary: [
-			"The delete operator is only meant to remove properties from objects, not variables.",
-			"Attempting to delete a variable in strict mode will cause a syntax error.",
-			"In non-strict mode, it will silently fail and return false without actually deleting the variable."
-		],
-		suggestions: ["Remove the delete statement, or if you need to unset the value, assign undefined instead."]
-	} },
-	setup(context) {
-		return { visitors: { DeleteExpression: (node, { sourceFile }) => {
-			if (node.expression.kind === SyntaxKind.Identifier) context.report({
-				message: "noDeleteVar",
-				range: {
-					begin: node.getStart(sourceFile),
-					end: node.getEnd()
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { variableDeletions_default as default };

package/lib/rules/voidOperator.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using the void operator.";
-    readonly id: "voidOperator";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noVoid", undefined>;
-export default _default;

package/lib/rules/voidOperator.js

@@ -1,32 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/voidOperator.ts
-var voidOperator_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using the void operator.",
-		id: "voidOperator",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { noVoid: {
-		primary: "Prefer an explicit value over using the void operator to produce undefined.",
-		secondary: [
-			"The void operator evaluates an expression and returns undefined, regardless of the expression's value.",
-			"This is often confusing and can be replaced with more explicit code.",
-			"Instead of using void, return or assign undefined directly."
-		],
-		suggestions: ["Replace void expressions with undefined or restructure the code to be more explicit."]
-	} },
-	setup(context) {
-		return { visitors: { VoidExpression: (node, { sourceFile }) => {
-			context.report({
-				message: "noVoid",
-				range: {
-					begin: node.getStart(sourceFile),
-					end: node.getEnd()
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { voidOperator_default as default };

package/lib/rules/withStatements.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using with statements";
-    readonly id: "withStatements";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "withStatement", undefined>;
-export default _default;

package/lib/rules/withStatements.js

@@ -1,28 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/withStatements.ts
-var withStatements_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using with statements",
-		id: "withStatements",
-		presets: ["javascript"]
-	},
-	messages: { withStatement: {
-		primary: "`with` statements are deprecated, unreliable, and difficult to reason about.",
-		secondary: ["The with statement is problematic because it adds members of an object to the current scope, making it impossible to tell what a variable inside the block actually refers to.", "If an object doesn't have an expected variable, you'll end up modifying a global instead of the expected property."],
-		suggestions: ["Create a variable with the content of the with expression and access its properties instead."]
-	} },
-	setup(context) {
-		return { visitors: { WithStatement: (node, { sourceFile }) => {
-			context.report({
-				message: "withStatement",
-				range: {
-					begin: node.getStart(sourceFile),
-					end: node.getStart(sourceFile) + 4
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { withStatements_default as default };

package/lib/rules/wrapperObjects.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Flags using `new` with `Boolean`, `Number`, or `String`, which creates wrapper objects instead of primitives.";
-    readonly id: "wrapperObjects";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "wrapperObject", undefined>;
-export default _default;

package/lib/rules/wrapperObjects.js

@@ -1,34 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/wrapperObjects.ts
-const wrapperConstructors = /* @__PURE__ */ new Set([
-	"Boolean",
-	"Number",
-	"String"
-]);
-var wrapperObjects_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Flags using `new` with `Boolean`, `Number`, or `String`, which creates wrapper objects instead of primitives.",
-		id: "wrapperObjects",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { wrapperObject: {
-		primary: "{{ name }} wrapper objects are rarely intended and can cause unexpected behavior.",
-		secondary: ["Using `new {{ name }}()` creates an object wrapper around a primitive value, not the primitive itself.", "Object wrappers behave differently from primitives in comparisons: `new String('a') !== 'a'`."],
-		suggestions: ["Use `{{ name }}()` without `new` to coerce values to primitives."]
-	} },
-	setup(context) {
-		return { visitors: { NewExpression: (node, { program, sourceFile, typeChecker }) => {
-			if (node.expression.kind !== ts$1.SyntaxKind.Identifier || !wrapperConstructors.has(node.expression.text) || !isGlobalDeclarationOfName(node.expression, node.expression.text, typeChecker, program)) return;
-			const range = getTSNodeRange(node, sourceFile);
-			context.report({
-				data: { name: node.expression.text },
-				message: "wrapperObject",
-				range
-			});
-		} } };
-	}
-});
-//#endregion
-export { wrapperObjects_default as default };

package/lib/type-utils/getSpecifierNames.d.ts

@@ -1,2 +0,0 @@
-import type { TypeOrValueSpecifier } from "./schemas.ts";
-export declare function getSpecifierNames(specifier: TypeOrValueSpecifier): string[] | undefined;

package/lib/type-utils/getSpecifierNames.js

@@ -1,7 +0,0 @@
-//#region src/type-utils/getSpecifierNames.ts
-function getSpecifierNames(specifier) {
-	if (specifier.name === void 0) return;
-	return Array.isArray(specifier.name) ? specifier.name : [specifier.name];
-}
-//#endregion
-export { getSpecifierNames };

package/lib/type-utils/isDeclaredInModuleBlock.d.ts

@@ -1,2 +0,0 @@
-import ts from "typescript";
-export declare function isDeclaredInModuleBlock(declaration: ts.Declaration, packageName: string): boolean;

package/lib/type-utils/isDeclaredInModuleBlock.js

@@ -1,12 +0,0 @@
-import ts from "typescript";
-//#region src/type-utils/isDeclaredInModuleBlock.ts
-function isDeclaredInModuleBlock(declaration, packageName) {
-	let current = declaration;
-	while (!ts.isSourceFile(current)) {
-		if (ts.isModuleDeclaration(current) && !(current.flags & ts.NodeFlags.Namespace) && ts.isStringLiteral(current.name) && current.name.text === packageName) return true;
-		current = current.parent;
-	}
-	return false;
-}
-//#endregion
-export { isDeclaredInModuleBlock };