@flint.fyi/ts 0.23.2 → 0.23.3

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { RuleCreator, createPlugin } from "@flint.fyi/core";
 import { declarationIncludesGlobal, forEachChild, getModifyingReferences, getScopeManager, getStaticNumberValue, getStaticStringValue, getStaticValue, getTSNodeRange, hasSameTokens, isBuiltinArrayMethod, isFunction, isGlobalDeclaration, isGlobalDeclarationOfName, isGlobalVariable, isInlineArrayCreation, typescriptLanguage, unwrapParentParenthesizedExpressions, unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
-import ts$1, { NodeFlags, SignatureKind, SymbolFlags, SyntaxKind, TypeFlags, getLeadingCommentRanges, getTrailingCommentRanges, isArrayLiteralExpression, isBigIntLiteral, isElementAccessExpression, isExpressionWithTypeArguments, isFunctionLike, isIdentifier, isInterfaceDeclaration, isLiteralExpression, isNewExpression, isNumericLiteral, isParenthesizedExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isShorthandPropertyAssignment, isSpreadElement, isStringLiteral, isTypeNode, isTypeParameterDeclaration, isVariableDeclaration } from "typescript";
+import ts$1, { NodeFlags, SignatureKind, SymbolFlags, SyntaxKind, TypeFlags, getLeadingCommentRanges, getTrailingCommentRanges, isLiteralExpression, isTypeNode } from "typescript";
 import * as tsutils from "ts-api-utils";
 import { isNodeFlagSet, isNullKeyword } from "ts-api-utils";
 import { nullThrows, pathKey } from "@flint.fyi/utils";
@@ -8,7 +8,7 @@ import z, { z as z$1 } from "zod/v4";
 import { RegExpParser, RegExpValidator, parseRegExpLiteral, visitRegExpAST } from "@eslint-community/regexpp";
 import { Chars, isPotentiallyEmpty, isZeroLength, toUnicodeSet } from "regexp-ast-analysis";
 import { analyse } from "scslre";
-import path from "node:path";
+import { resolve } from "pathe";
 //#region src/rules/ruleCreator.ts
 const ruleCreator = new RuleCreator({
 	docs: (ruleId) => `https://flint.fyi/rules/ts/${ruleId.toLowerCase()}`,
@@ -184,8 +184,8 @@ var accessorThisRecursion_default = ruleCreator.createRule(typescriptLanguage, {
 			const isGetter = accessor.kind === SyntaxKind.GetAccessor;
 			function checkNode(node) {
 				if (tsutils.isFunctionScopeBoundary(node)) return;
-				if (ts$1.isPropertyAccessExpression(node)) checkPropertyAccessExpression(node);
-				ts$1.forEachChild(node, checkNode);
+				if (node.kind === SyntaxKind.PropertyAccessExpression) checkPropertyAccessExpression(node);
+				forEachChild(node, checkNode);
 			}
 			function checkPropertyAccessExpression(node) {
 				if (node.name.text !== propertyName || node.expression.kind !== SyntaxKind.ThisKeyword) return;
@@ -196,7 +196,7 @@ var accessorThisRecursion_default = ruleCreator.createRule(typescriptLanguage, {
 						end: node.getEnd()
 					}
 				});
-				else if (ts$1.isBinaryExpression(node.parent) && node.parent.left === node && node.parent.operatorToken.kind === SyntaxKind.EqualsToken) context.report({
+				else if (node.parent.kind === SyntaxKind.BinaryExpression && node.parent.left === node && node.parent.operatorToken.kind === SyntaxKind.EqualsToken) context.report({
 					message: "noSetterRecursion",
 					range: {
 						begin: node.getStart(sourceFile),
@@ -204,7 +204,7 @@ var accessorThisRecursion_default = ruleCreator.createRule(typescriptLanguage, {
 					}
 				});
 			}
-			ts$1.forEachChild(accessor.body, checkNode);
+			forEachChild(accessor.body, checkNode);
 		}
 		return { visitors: {
 			GetAccessor: checkAccessor,
@@ -461,7 +461,7 @@ var anyArguments_default = ruleCreator.createRule(typescriptLanguage, {
 			const lastParam = parameters.at(-1);
 			if (!lastParam) return;
 			const lastParamDeclaration = lastParam.declarations?.[0];
-			if (lastParamDeclaration && ts$1.isParameter(lastParamDeclaration) && lastParamDeclaration.dotDotDotToken) {
+			if (lastParamDeclaration?.kind === SyntaxKind.Parameter && lastParamDeclaration.dotDotDotToken) {
 				if (index < parameters.length - 1) {
 					const param = parameters[index];
 					if (!param) return;
@@ -581,7 +581,7 @@ var anyAssignments_default = ruleCreator.createRule(typescriptLanguage, {
 			let didReport = false;
 			for (let i = 0; i < pattern.elements.length; i++) {
 				const element = pattern.elements[i];
-				if (!element || ts$1.isOmittedExpression(element)) continue;
+				if (!element || element.kind === SyntaxKind.OmittedExpression) continue;
 				if (element.dotDotDotToken) continue;
 				const elementType = tupleElements[i];
 				if (!elementType) continue;
@@ -596,8 +596,8 @@ var anyAssignments_default = ruleCreator.createRule(typescriptLanguage, {
 						}
 					});
 					didReport = true;
-				} else if (ts$1.isArrayBindingPattern(name)) didReport = checkArrayDestructureWorker(name, elementType, sourceFile, typeChecker) || didReport;
-				else if (ts$1.isObjectBindingPattern(name)) didReport = checkObjectDestructureWorker(name, elementType, sourceFile, typeChecker) || didReport;
+				} else if (name.kind === SyntaxKind.ArrayBindingPattern) didReport = checkArrayDestructureWorker(name, elementType, sourceFile, typeChecker) || didReport;
+				else if (name.kind === SyntaxKind.ObjectBindingPattern) didReport = checkObjectDestructureWorker(name, elementType, sourceFile, typeChecker) || didReport;
 			}
 			return didReport;
 		}
@@ -607,10 +607,10 @@ var anyAssignments_default = ruleCreator.createRule(typescriptLanguage, {
 				if (element.dotDotDotToken) continue;
 				let key;
 				const propertyName = element.propertyName ?? element.name;
-				if (ts$1.isIdentifier(propertyName) || ts$1.isStringLiteral(propertyName) || ts$1.isNumericLiteral(propertyName)) key = propertyName.text;
-				else if (ts$1.isComputedPropertyName(propertyName)) {
+				if (propertyName.kind === SyntaxKind.Identifier || propertyName.kind === SyntaxKind.StringLiteral || propertyName.kind === SyntaxKind.NumericLiteral) key = propertyName.text;
+				else if (propertyName.kind === SyntaxKind.ComputedPropertyName) {
 					const expression = propertyName.expression;
-					if (ts$1.isStringLiteral(expression) || ts$1.isNoSubstitutionTemplateLiteral(expression)) key = expression.text;
+					if (expression.kind === SyntaxKind.StringLiteral || expression.kind === SyntaxKind.NoSubstitutionTemplateLiteral) key = expression.text;
 				}
 				if (key === void 0) continue;
 				const propertySymbol = senderType.getProperty(key);
@@ -627,8 +627,8 @@ var anyAssignments_default = ruleCreator.createRule(typescriptLanguage, {
 						}
 					});
 					didReport = true;
-				} else if (ts$1.isArrayBindingPattern(name)) didReport = checkArrayDestructureWorker(name, propertyType, sourceFile, typeChecker) || didReport;
-				else if (ts$1.isObjectBindingPattern(name)) didReport = checkObjectDestructureWorker(name, propertyType, sourceFile, typeChecker) || didReport;
+				} else if (name.kind === SyntaxKind.ArrayBindingPattern) didReport = checkArrayDestructureWorker(name, propertyType, sourceFile, typeChecker) || didReport;
+				else if (name.kind === SyntaxKind.ObjectBindingPattern) didReport = checkObjectDestructureWorker(name, propertyType, sourceFile, typeChecker) || didReport;
 			}
 			return didReport;
 		}
@@ -1044,8 +1044,8 @@ var anyReturns_default = ruleCreator.createRule(typescriptLanguage, {
 //#endregion
 //#region src/rules/arguments.ts
 function isNonArrowFunctionBoundary(node) {
-	if (ts$1.isArrowFunction(node)) return "quit";
-	return ts$1.isFunctionDeclaration(node) || ts$1.isFunctionExpression(node) || ts$1.isMethodDeclaration(node) || ts$1.isGetAccessorDeclaration(node) || ts$1.isSetAccessorDeclaration(node) || ts$1.isConstructorDeclaration(node);
+	if (node.kind === SyntaxKind.ArrowFunction) return "quit";
+	return node.kind === SyntaxKind.FunctionDeclaration || node.kind === SyntaxKind.FunctionExpression || node.kind === SyntaxKind.MethodDeclaration || node.kind === SyntaxKind.GetAccessor || node.kind === SyntaxKind.SetAccessor || node.kind === SyntaxKind.Constructor;
 }
 var arguments_default = ruleCreator.createRule(typescriptLanguage, {
 	about: {
@@ -1065,7 +1065,7 @@ var arguments_default = ruleCreator.createRule(typescriptLanguage, {
 			if ((parent.kind === SyntaxKind.PropertyAccessExpression || parent.kind === SyntaxKind.PropertyAssignment || parent.kind === SyntaxKind.ShorthandPropertyAssignment || parent.kind === SyntaxKind.Parameter || parent.kind === SyntaxKind.VariableDeclaration || parent.kind === SyntaxKind.PropertyDeclaration || parent.kind === SyntaxKind.BindingElement || parent.kind === SyntaxKind.PropertySignature) && parent.name === node) return;
 			if (!ts$1.findAncestor(node, isNonArrowFunctionBoundary)) return;
 			const symbol = typeChecker.getSymbolAtLocation(node);
-			if (!symbol || symbol.getDeclarations()?.some((declaration) => ts$1.isParameter(declaration) || ts$1.isVariableDeclaration(declaration) || ts$1.isPropertyDeclaration(declaration) || ts$1.isBindingElement(declaration))) return;
+			if (!symbol || symbol.getDeclarations()?.some((declaration) => declaration.kind === SyntaxKind.Parameter || declaration.kind === SyntaxKind.VariableDeclaration || declaration.kind === SyntaxKind.PropertyDeclaration || declaration.kind === SyntaxKind.BindingElement)) return;
 			context.report({
 				message: "preferRestParameters",
 				range: getTSNodeRange(node, sourceFile)
@@ -3016,17 +3016,20 @@ var catchCallbackTypes_default = ruleCreator.createRule(typescriptLanguage, {
 			if (symbol?.getName() !== "Promise") return false;
 			const declarations = symbol.getDeclarations();
 			if (!declarations) return false;
-			return declarations.some((declaration) => isInterfaceDeclaration(declaration) && declaration.name.text === "Promise" && declarationIncludesGlobal(declaration, program));
+			return declarations.some((declaration) => {
+				const node = declaration;
+				return node.kind === SyntaxKind.InterfaceDeclaration && node.name.text === "Promise" && declarationIncludesGlobal(declaration, program);
+			});
 		}
 		function isCatchOrThenCallback(node, typeChecker, program) {
-			if (!isPropertyAccessExpression(node.expression)) return;
+			if (node.expression.kind !== SyntaxKind.PropertyAccessExpression) return;
 			const methodName = node.expression.name.text;
 			if (methodName !== "catch" && methodName !== "then") return;
 			if (!isGlobalPromiseType(getConstrainedTypeAtLocation(node.expression.expression, typeChecker), program)) return;
 			return methodName === "catch" ? "catch" : "then";
 		}
 		function checkCallbackParameter(callback, sourceFile, typeChecker) {
-			if (!isFunctionLike(callback) || !callback.parameters.length) return;
+			if (callback.kind !== SyntaxKind.ArrowFunction && callback.kind !== SyntaxKind.FunctionExpression || !callback.parameters.length) return;
 			const firstParameter = callback.parameters[0];
 			if (firstParameter.type) {
 				const paramType = typeChecker.getTypeFromTypeNode(firstParameter.type);
@@ -3329,17 +3332,15 @@ function classImplementsSomething(classNode) {
 function containsThis$1(node) {
 	switch (node.kind) {
 		case SyntaxKind.ClassDeclaration:
-		case SyntaxKind.ClassExpression: {
-			const classNode = node;
-			for (const member of classNode.members) if (ts$1.isPropertyDeclaration(member) && ts$1.isComputedPropertyName(member.name) && containsThis$1(member.name.expression)) return true;
+		case SyntaxKind.ClassExpression:
+			for (const member of node.members) if (member.kind === SyntaxKind.PropertyDeclaration && member.name.kind === SyntaxKind.ComputedPropertyName && containsThis$1(member.name.expression)) return true;
 			return false;
-		}
 		case SyntaxKind.ClassStaticBlockDeclaration:
 		case SyntaxKind.FunctionDeclaration:
 		case SyntaxKind.FunctionExpression: return false;
 		case SyntaxKind.SuperKeyword:
 		case SyntaxKind.ThisKeyword: return true;
-		default: return ts$1.forEachChild(node, containsThis$1) ?? false;
+		default: return forEachChild(node, containsThis$1) ?? false;
 	}
 }
 function getMemberDisplayName(member, sourceFile) {
@@ -3658,7 +3659,7 @@ var constructorGenericCalls_default = ruleCreator.createRule(typescriptLanguage,
 				}
 				return;
 			}
-			if (!ts$1.isTypeReferenceNode(typeAnnotation) || typeAnnotation.typeName.kind !== SyntaxKind.Identifier || typeAnnotation.typeName.text !== constructorName || isBuiltInTypedArray(typeAnnotation.typeName.text) || !!typeAnnotation.typeArguments !== !initializer.typeArguments) return;
+			if (typeAnnotation.kind !== SyntaxKind.TypeReference || typeAnnotation.typeName.kind !== SyntaxKind.Identifier || typeAnnotation.typeName.text !== constructorName || isBuiltInTypedArray(typeAnnotation.typeName.text) || !!typeAnnotation.typeArguments !== !initializer.typeArguments) return;
 			if (style === "constructor" && typeAnnotation.typeArguments && !initializer.typeArguments) {
 				const typeArgsText = getTypeArgumentsText(typeAnnotation, typeAnnotation.typeArguments, sourceFile);
 				const typeArgsRange = getTypeArgumentsRange(typeAnnotation, typeAnnotation.typeArguments, sourceFile);
@@ -4206,8 +4207,8 @@ function isInsideHeritageClause(node) {
 	if (node.kind === SyntaxKind.HeritageClause) return true;
 	let current = node.parent;
 	while (current) {
-		if (ts$1.isHeritageClause(current)) return true;
-		if (ts$1.isSourceFile(current) || ts$1.isClassDeclaration(current)) break;
+		if (current.kind === SyntaxKind.HeritageClause) return true;
+		if (current.kind === SyntaxKind.SourceFile || current.kind === SyntaxKind.ClassDeclaration) break;
 		current = current.parent;
 	}
 	return false;
@@ -4216,8 +4217,8 @@ function isInsideImport(node) {
 	if (node.kind === SyntaxKind.ImportDeclaration) return true;
 	let current = node.parent;
 	while (current) {
-		if (ts$1.isImportDeclaration(current)) return true;
-		if (ts$1.isSourceFile(current) || ts$1.isFunctionDeclaration(current) || ts$1.isFunctionExpression(current) || ts$1.isArrowFunction(current) || ts$1.isClassDeclaration(current) || ts$1.isClassExpression(current) || ts$1.isBlock(current)) return false;
+		if (current.kind === SyntaxKind.ImportDeclaration) return true;
+		if (current.kind === SyntaxKind.SourceFile || current.kind === SyntaxKind.FunctionDeclaration || current.kind === SyntaxKind.FunctionExpression || current.kind === SyntaxKind.ArrowFunction || current.kind === SyntaxKind.ClassDeclaration || current.kind === SyntaxKind.ClassExpression || current.kind === SyntaxKind.Block) return false;
 		current = current.parent;
 	}
 	return false;
@@ -4277,7 +4278,7 @@ var destructuringConsistency_default = ruleCreator.createRule(typescriptLanguage
 				const propertyName = node.name.text;
 				if (!destructured.destructuredProperties.has(propertyName)) return;
 				const variableName = destructured.destructuredProperties.get(propertyName);
-				if (ts$1.isCallExpression(node.parent) && node.parent.expression === node || isLeftHandSide$1(node)) return;
+				if (node.parent.kind === SyntaxKind.CallExpression && node.parent.expression === node || isLeftHandSide$1(node)) return;
 				const range = getTSNodeRange(node, sourceFile);
 				const expression = node.getText(sourceFile);
 				const [variable, suggestions] = variableName ? [variableName, [{
@@ -4299,19 +4300,16 @@ var destructuringConsistency_default = ruleCreator.createRule(typescriptLanguage
 				destructuredObjects.length = 0;
 			},
 			VariableDeclaration: (node, { sourceFile }) => {
-				if (!node.initializer || !ts$1.isObjectBindingPattern(node.name)) return;
+				if (!node.initializer || node.name.kind !== SyntaxKind.ObjectBindingPattern) return;
 				const initKey = getInitializerKey(node.initializer);
 				if (!initKey) return;
 				const properties = /* @__PURE__ */ new Map();
-				for (const element of node.name.elements) {
-					if (!ts$1.isBindingElement(element)) continue;
-					if (element.propertyName) {
-						if (ts$1.isIdentifier(element.propertyName)) {
-							if (ts$1.isObjectBindingPattern(element.name) || ts$1.isArrayBindingPattern(element.name)) properties.set(element.propertyName.text, null);
-							else if (ts$1.isIdentifier(element.name)) properties.set(element.propertyName.text, element.name.text);
-						}
-					} else if (ts$1.isIdentifier(element.name)) properties.set(element.name.text, element.name.text);
-				}
+				for (const element of node.name.elements) if (element.propertyName) {
+					if (element.propertyName.kind === SyntaxKind.Identifier) {
+						if (element.name.kind === SyntaxKind.ObjectBindingPattern || element.name.kind === SyntaxKind.ArrayBindingPattern) properties.set(element.propertyName.text, null);
+						else properties.set(element.propertyName.text, element.name.text);
+					}
+				} else if (element.name.kind === SyntaxKind.Identifier) properties.set(element.name.text, element.name.text);
 				if (properties.size) destructuredObjects.push({
 					declarationEnd: node.getEnd(),
 					destructuredProperties: properties,
@@ -4364,7 +4362,7 @@ var duplicateArguments_default = ruleCreator.createRule(typescriptLanguage, {
 //#endregion
 //#region src/rules/dynamicDeletes.ts
 function isAcceptableIndexExpression(property) {
-	return isStringLiteral(property) || isNumericLiteral(property) || isPrefixUnaryExpression(property) && property.operator === SyntaxKind.MinusToken && isNumericLiteral(property.operand);
+	return property.kind === SyntaxKind.StringLiteral || property.kind === SyntaxKind.NumericLiteral || property.kind === SyntaxKind.PrefixUnaryExpression && property.operator === SyntaxKind.MinusToken && property.operand.kind === SyntaxKind.NumericLiteral;
 }
 var dynamicDeletes_default = ruleCreator.createRule(typescriptLanguage, {
 	about: {
@@ -4380,7 +4378,7 @@ var dynamicDeletes_default = ruleCreator.createRule(typescriptLanguage, {
 	setup(context) {
 		return { visitors: { DeleteExpression: (node, { sourceFile }) => {
 			const argument = node.expression;
-			if (!isElementAccessExpression(argument) || isAcceptableIndexExpression(argument.argumentExpression)) return;
+			if (argument.kind !== SyntaxKind.ElementAccessExpression || isAcceptableIndexExpression(argument.argumentExpression)) return;
 			const property = argument.argumentExpression;
 			context.report({
 				message: "dynamicDelete",
@@ -5230,7 +5228,7 @@ function isErrorSubclass(node, typeChecker, program) {
 		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;
+			if (typeName.kind === SyntaxKind.Identifier && builtinErrorNames.has(typeName.text) && isGlobalDeclaration(typeName, typeChecker, program)) return true;
 		}
 	}
 	return false;
@@ -5375,15 +5373,13 @@ var errorSubclassProperties_default = ruleCreator.createRule(typescriptLanguage,
 //#endregion
 //#region src/rules/errorUnnecessaryCaptureStackTraces.ts
 function isCaptureStackTraceCall(node) {
-	if (!ts$1.isCallExpression(node) && !ts$1.isOptionalChain(node)) return false;
-	const callExpression = ts$1.isCallExpression(node) ? node : void 0;
-	if (!callExpression) return ts$1.isCallExpression(node) && isCaptureStackTraceCall(node);
-	return ts$1.isPropertyAccessExpression(callExpression.expression) && ts$1.isIdentifier(callExpression.expression.expression) && callExpression.expression.expression.text === "Error" && ts$1.isIdentifier(callExpression.expression.name) && callExpression.expression.name.text === "captureStackTrace";
+	if (node.kind !== SyntaxKind.CallExpression) return false;
+	return node.expression.kind === SyntaxKind.PropertyAccessExpression && node.expression.expression.kind === SyntaxKind.Identifier && node.expression.expression.text === "Error" && node.expression.name.text === "captureStackTrace";
 }
 function isValidSecondArgument(node, className) {
-	if (ts$1.isIdentifier(node)) return node.text === className;
-	if (ts$1.isPropertyAccessExpression(node) && node.expression.kind === SyntaxKind.ThisKeyword && ts$1.isIdentifier(node.name) && node.name.text === "constructor") return true;
-	if (ts$1.isMetaProperty(node) && node.keywordToken === SyntaxKind.NewKeyword && ts$1.isIdentifier(node.name) && node.name.text === "target") return true;
+	if (node.kind === SyntaxKind.Identifier) return node.text === className;
+	if (node.kind === SyntaxKind.PropertyAccessExpression && node.expression.kind === SyntaxKind.ThisKeyword && node.name.kind === SyntaxKind.Identifier && node.name.text === "constructor") return true;
+	if (node.kind === SyntaxKind.MetaProperty && node.keywordToken === SyntaxKind.NewKeyword && node.name.text === "target") return true;
 	return false;
 }
 var errorUnnecessaryCaptureStackTraces_default = ruleCreator.createRule(typescriptLanguage, {
@@ -5401,9 +5397,9 @@ var errorUnnecessaryCaptureStackTraces_default = ruleCreator.createRule(typescri
 		return { visitors: { ClassDeclaration: (node, { program, sourceFile, typeChecker }) => {
 			if (!isErrorSubclass(node, typeChecker, program)) return;
 			for (const member of node.members) {
-				if (!ts$1.isConstructorDeclaration(member) || !member.body) continue;
+				if (member.kind !== SyntaxKind.Constructor || !member.body) continue;
 				for (const statement of member.body.statements) {
-					if (statement.kind !== SyntaxKind.ExpressionStatement || !(statement.expression.kind === SyntaxKind.CallExpression || ts$1.isCallChain(statement.expression)) || !isCaptureStackTraceCall(statement.expression)) continue;
+					if (statement.kind !== SyntaxKind.ExpressionStatement || statement.expression.kind !== SyntaxKind.CallExpression || !isCaptureStackTraceCall(statement.expression)) continue;
 					const args = statement.expression.arguments;
 					if (args.length < 1) continue;
 					if (args[0].kind !== SyntaxKind.ThisKeyword) continue;
@@ -5665,8 +5661,8 @@ function getImportInfo(node, sourceFile) {
 	const clause = node.importClause;
 	if (clause.name) info.defaultImport = clause.name.text;
 	if (clause.namedBindings) {
-		if (ts$1.isNamespaceImport(clause.namedBindings)) info.namespaceImport = clause.namedBindings.name.text;
-		else if (ts$1.isNamedImports(clause.namedBindings)) for (const element of clause.namedBindings.elements) {
+		if (clause.namedBindings.kind === SyntaxKind.NamespaceImport) info.namespaceImport = clause.namedBindings.name.text;
+		else for (const element of clause.namedBindings.elements) {
 			const importedName = element.propertyName ? element.propertyName.text : element.name.text;
 			const localName = element.name.text;
 			info.namedImports.set(localName, importedName);
@@ -5720,7 +5716,7 @@ var exportFromImports_default = ruleCreator.createRule(typescriptLanguage, {
 				}
 			}
 			for (const exportDeclaration of namedExports) {
-				if (!exportDeclaration.exportClause || !ts$1.isNamedExports(exportDeclaration.exportClause)) continue;
+				if (exportDeclaration.exportClause?.kind !== SyntaxKind.NamedExports) continue;
 				for (const element of exportDeclaration.exportClause.elements) {
 					const localName = element.propertyName ? element.propertyName.text : element.name.text;
 					const exportedName = element.name.text;
@@ -5753,7 +5749,7 @@ var exportFromImports_default = ruleCreator.createRule(typescriptLanguage, {
 				}
 			}
 			for (const exportAssignment of exportAssignments) {
-				if (!ts$1.isIdentifier(exportAssignment.expression)) continue;
+				if (exportAssignment.expression.kind !== SyntaxKind.Identifier) continue;
 				const localName = exportAssignment.expression.text;
 				const importInfo = imports.get(localName);
 				if (importInfo?.defaultImport !== localName) continue;
@@ -7147,8 +7143,8 @@ function isLiteralArgument(node, constructorName) {
 	switch (constructorName) {
 		case "BigInt": return isNumericLiteralForBigInt(node);
 		case "Boolean": return isLiteralExpression(node) || isBooleanLiteral(node);
-		case "Number": return isStringLiteral(node) && isValidNumericString(node.text);
-		case "String": return isNumericLiteral(node) || isBooleanLiteral(node) || isBigIntLiteral(node);
+		case "Number": return node.kind === SyntaxKind.StringLiteral && isValidNumericString(node.text);
+		case "String": return node.kind === SyntaxKind.NumericLiteral || isBooleanLiteral(node) || node.kind === SyntaxKind.BigIntLiteral;
 		default: return false;
 	}
 }
@@ -7174,7 +7170,7 @@ var literalConstructorWrappers_default = ruleCreator.createRule(typescriptLangua
 	} },
 	setup(context) {
 		return { visitors: { CallExpression: (node, { program, sourceFile, typeChecker }) => {
-			if (!isIdentifier(node.expression)) return;
+			if (node.expression.kind !== SyntaxKind.Identifier) return;
 			const name = node.expression.text;
 			if (!literalConstructors.has(name) || node.arguments.length !== 1 || !isGlobalDeclarationOfName(node.expression, name, typeChecker, program)) return;
 			const argument = node.arguments[0];
@@ -8397,21 +8393,21 @@ function hasNoAssignmentBeforeNode(identifier, node, sourceFile, typeChecker) {
 	const nodeEnd = node.getEnd();
 	for (const declaration of declarations) {
 		if (declaration.getEnd() >= nodeEnd) continue;
-		if (ts$1.isVariableDeclaration(declaration)) {
+		if (declaration.kind === SyntaxKind.VariableDeclaration) {
 			if (declaration.exclamationToken || declaration.initializer) return false;
-		} else if (ts$1.isParameter(declaration) && declaration.initializer) return false;
+		} else if (declaration.kind === SyntaxKind.Parameter && declaration.initializer) return false;
 	}
 	const valueDeclaration = symbol.valueDeclaration;
 	if (!valueDeclaration) return true;
 	function findModifyingReference(current) {
-		if (ts$1.isIdentifier(current)) {
+		if (current.kind === SyntaxKind.Identifier) {
 			if (typeChecker.getSymbolAtLocation(current)?.valueDeclaration === valueDeclaration) {
 				const parent = current.parent;
-				if (ts$1.isBinaryExpression(parent) && tsutils.isAssignmentKind(parent.operatorToken.kind) && parent.left === current && parent.getEnd() < nodeEnd) return true;
-				if ((ts$1.isPostfixUnaryExpression(parent) || ts$1.isPrefixUnaryExpression(parent)) && parent.operand === current && parent.getEnd() < nodeEnd) return true;
+				if (parent.kind === SyntaxKind.BinaryExpression && tsutils.isAssignmentKind(parent.operatorToken.kind) && parent.left === current && parent.getEnd() < nodeEnd) return true;
+				if ((parent.kind === SyntaxKind.PostfixUnaryExpression || parent.kind === SyntaxKind.PrefixUnaryExpression) && parent.operand === current && parent.getEnd() < nodeEnd) return true;
 			}
 		}
-		return ts$1.forEachChild(current, findModifyingReference) ?? false;
+		return forEachChild(current, findModifyingReference) ?? false;
 	}
 	return !findModifyingReference(sourceFile);
 }
@@ -9158,16 +9154,16 @@ var numberMethodRanges_default = ruleCreator.createRule(typescriptLanguage, {
 //#region src/rules/numberStaticMethods.ts
 const globalReplacements = /* @__PURE__ */ new Map([["isFinite", "Number.isFinite"], ["isNaN", "Number.isNaN"]]);
 function isDeclarationName(node) {
-	return ts$1.isFunctionDeclaration(node.parent) && node.parent.name === node || ts$1.isVariableDeclaration(node.parent) && node.parent.name === node || ts$1.isParameter(node.parent) && node.parent.name === node;
+	return node.parent.kind === SyntaxKind.FunctionDeclaration && node.parent.name === node || node.parent.kind === SyntaxKind.VariableDeclaration && node.parent.name === node || node.parent.kind === SyntaxKind.Parameter && node.parent.name === node;
 }
 function isLeftHandSide(node) {
 	return node.parent.kind === SyntaxKind.BinaryExpression && node.parent.left === node && node.parent.operatorToken.kind >= SyntaxKind.FirstAssignment && node.parent.operatorToken.kind <= SyntaxKind.LastAssignment;
 }
 function isPropertyAccessOfNode(node) {
-	return ts$1.isPropertyAccessExpression(node.parent) && node.parent.name === node;
+	return node.parent.kind === SyntaxKind.PropertyAccessExpression && node.parent.name === node;
 }
 function isPropertyShorthandOfNode(node) {
-	return ts$1.isShorthandPropertyAssignment(node.parent) && node.parent.name === node;
+	return node.parent.kind === SyntaxKind.ShorthandPropertyAssignment && node.parent.name === node;
 }
 var numberStaticMethods_default = ruleCreator.createRule(typescriptLanguage, {
 	about: {
@@ -10160,7 +10156,7 @@ function getMethodDisplayName(method) {
 function getNameFromPropertyName(name) {
 	switch (name.kind) {
 		case SyntaxKind.ComputedPropertyName:
-			if (ts$1.isStringLiteral(name.expression)) return {
+			if (name.expression.kind === SyntaxKind.StringLiteral) return {
 				name: name.expression.text,
 				type: "quoted"
 			};
@@ -10551,7 +10547,7 @@ function isDescendantOf(node, potentialAncestor) {
 }
 function isNodeInsideReturnType(node) {
 	let current = node.parent;
-	while (current) {
+	while (current.kind !== SyntaxKind.SourceFile) {
 		if (current.kind === SyntaxKind.FunctionDeclaration || current.kind === SyntaxKind.FunctionExpression || current.kind === SyntaxKind.ArrowFunction || current.kind === SyntaxKind.MethodDeclaration || current.kind === SyntaxKind.MethodSignature || current.kind === SyntaxKind.FunctionType || current.kind === SyntaxKind.CallSignature || current.kind === SyntaxKind.ConstructSignature || current.kind === SyntaxKind.ConstructorType) return !!current.type && isDescendantOf(node, current.type);
 		current = current.parent;
 	}
@@ -15229,10 +15225,10 @@ function extractCallExpression(expression) {
 function findAssignmentsToSymbol(symbol, sourceFile, typeChecker) {
 	const assignments = [];
 	function visit(node) {
-		if (ts$1.isBinaryExpression(node) && node.operatorToken.kind === SyntaxKind.EqualsToken && ts$1.isIdentifier(node.left)) {
+		if (node.kind === SyntaxKind.BinaryExpression && node.operatorToken.kind === SyntaxKind.EqualsToken && node.left.kind === SyntaxKind.Identifier) {
 			if (typeChecker.getSymbolAtLocation(node.left) === symbol) assignments.push(node);
 		}
-		ts$1.forEachChild(node, visit);
+		forEachChild(node, visit);
 	}
 	visit(sourceFile);
 	return assignments;
@@ -15312,7 +15308,7 @@ function getRegexInfoFromExpression(node, typeChecker, sourceFile) {
 		if (symbol) {
 			const declarations = symbol.getDeclarations();
 			if (declarations) {
-				for (const declaration of declarations) if (ts$1.isVariableDeclaration(declaration) && declaration.initializer) return getRegexInfoFromExpression(declaration.initializer, typeChecker, sourceFile);
+				for (const declaration of declarations) if (declaration.kind === SyntaxKind.VariableDeclaration && declaration.initializer) return getRegexInfoFromExpression(declaration.initializer, typeChecker, sourceFile);
 			}
 		}
 	}
@@ -15320,7 +15316,7 @@ function getRegexInfoFromExpression(node, typeChecker, sourceFile) {
 function getRegexInfoFromSymbol(symbol, typeChecker, sourceFile) {
 	const declarations = symbol.getDeclarations();
 	if (declarations) for (const declaration of declarations) {
-		if (ts$1.isVariableDeclaration(declaration) && declaration.initializer) {
+		if (declaration.kind === SyntaxKind.VariableDeclaration && declaration.initializer) {
 			const callExpression = extractCallExpression(declaration.initializer);
 			if (callExpression) {
 				const regexInfo = getRegexFromCall(callExpression, typeChecker, sourceFile);
@@ -15330,7 +15326,7 @@ function getRegexInfoFromSymbol(symbol, typeChecker, sourceFile) {
 				}
 			}
 		}
-		if (ts$1.isParameter(declaration)) continue;
+		if (declaration.kind === SyntaxKind.Parameter) continue;
 	}
 	const assignments = findAssignmentsToSymbol(symbol, sourceFile, typeChecker);
 	for (const assignment of assignments) {
@@ -18865,14 +18861,14 @@ function getSpecifierNames(specifier) {
 function isFromFile(sourceFile, specifiedPath, program) {
 	if (specifiedPath === void 0) return !sourceFile.fileName.includes("/node_modules/") && !program.isSourceFileDefaultLibrary(sourceFile);
 	const caseSensitive = ts$1.sys.useCaseSensitiveFileNames;
-	return pathKey(sourceFile.fileName, caseSensitive) === pathKey(path.resolve(program.getCurrentDirectory(), specifiedPath), caseSensitive);
+	return pathKey(sourceFile.fileName, caseSensitive) === pathKey(resolve(program.getCurrentDirectory(), specifiedPath), caseSensitive);
 }
 //#endregion
 //#region src/type-utils/isDeclaredInModuleBlock.ts
 function isDeclaredInModuleBlock(declaration, packageName) {
 	let current = declaration;
-	while (!ts$1.isSourceFile(current)) {
-		if (ts$1.isModuleDeclaration(current) && !(current.flags & ts$1.NodeFlags.Namespace) && ts$1.isStringLiteral(current.name) && current.name.text === packageName) return true;
+	while (current.kind !== SyntaxKind.SourceFile) {
+		if (current.kind === SyntaxKind.ModuleDeclaration && !(current.flags & NodeFlags.Namespace) && current.name.kind === SyntaxKind.StringLiteral && current.name.text === packageName) return true;
 		current = current.parent;
 	}
 	return false;
@@ -19268,20 +19264,20 @@ var sequences_default = ruleCreator.createRule(typescriptLanguage, {
 //#endregion
 //#region src/rules/setSizeLengthChecks.ts
 function isNewSetExpression(expression, typeChecker, program) {
-	return isNewExpression(expression) && isIdentifier(expression.expression) && expression.expression.text === "Set" && isGlobalDeclarationOfName(expression.expression, "Set", typeChecker, program);
+	return expression.kind === SyntaxKind.NewExpression && expression.expression.kind === SyntaxKind.Identifier && expression.expression.text === "Set" && isGlobalDeclarationOfName(expression.expression, "Set", typeChecker, program);
 }
 function isSetExpression(expression, typeChecker, program) {
 	const unwrapped = unwrapParentheses$1(expression);
 	if (isNewSetExpression(unwrapped, typeChecker, program)) return true;
-	if (!isIdentifier(unwrapped)) return false;
+	if (unwrapped.kind !== SyntaxKind.Identifier) return false;
 	const symbol = typeChecker.getSymbolAtLocation(unwrapped);
-	if (!symbol?.valueDeclaration || !isVariableDeclaration(symbol.valueDeclaration)) return false;
+	if (symbol?.valueDeclaration?.kind !== SyntaxKind.VariableDeclaration) return false;
 	const declaration = symbol.valueDeclaration;
 	if (declaration.parent.kind !== SyntaxKind.VariableDeclarationList || !(declaration.parent.flags & NodeFlags.Const) || !declaration.initializer) return false;
 	return isNewSetExpression(unwrapParentheses$1(declaration.initializer), typeChecker, program);
 }
 function unwrapParentheses$1(expression) {
-	while (isParenthesizedExpression(expression)) expression = expression.expression;
+	while (expression.kind === SyntaxKind.ParenthesizedExpression) expression = expression.expression;
 	return expression;
 }
 var setSizeLengthChecks_default = ruleCreator.createRule(typescriptLanguage, {
@@ -19297,9 +19293,9 @@ var setSizeLengthChecks_default = ruleCreator.createRule(typescriptLanguage, {
 	} },
 	setup(context) {
 		return { visitors: { PropertyAccessExpression: (node, { program, sourceFile, typeChecker }) => {
-			if (node.questionDotToken || node.name.text !== "length" || !isArrayLiteralExpression(node.expression) || node.expression.elements.length !== 1) return;
+			if (node.questionDotToken || node.name.text !== "length" || node.expression.kind !== SyntaxKind.ArrayLiteralExpression || node.expression.elements.length !== 1) return;
 			const element = node.expression.elements[0];
-			if (!isSpreadElement(element) || !isSetExpression(element.expression, typeChecker, program)) return;
+			if (element.kind !== SyntaxKind.SpreadElement || !isSetExpression(element.expression, typeChecker, program)) return;
 			context.report({
 				message: "preferSize",
 				range: getTSNodeRange(node, sourceFile)
@@ -19613,7 +19609,7 @@ var sparseArrays_default = ruleCreator.createRule(typescriptLanguage, {
 //#endregion
 //#region src/rules/staticMemberOnlyClasses.ts
 function hasDecorators(node) {
-	return node.modifiers?.some(ts$1.isDecorator) ?? false;
+	return node.modifiers?.some((modifier) => modifier.kind === SyntaxKind.Decorator) ?? false;
 }
 function hasExtendsClause(node) {
 	return node.heritageClauses?.some((clause) => clause.token === SyntaxKind.ExtendsKeyword) ?? false;
@@ -20121,8 +20117,8 @@ function hasExportModifier(node) {
 }
 function isInsideFunction(node) {
 	let current = node.parent;
-	while (current) {
-		if (ts$1.isFunctionDeclaration(current) || ts$1.isFunctionExpression(current) || ts$1.isArrowFunction(current) || ts$1.isMethodDeclaration(current) || ts$1.isConstructorDeclaration(current) || ts$1.isGetAccessorDeclaration(current) || ts$1.isSetAccessorDeclaration(current)) return true;
+	while (current.kind !== SyntaxKind.SourceFile) {
+		if (current.kind === SyntaxKind.FunctionDeclaration || current.kind === SyntaxKind.FunctionExpression || current.kind === SyntaxKind.ArrowFunction || current.kind === SyntaxKind.MethodDeclaration || current.kind === SyntaxKind.Constructor || current.kind === SyntaxKind.GetAccessor || current.kind === SyntaxKind.SetAccessor) return true;
 		current = current.parent;
 	}
 	return false;
@@ -20441,7 +20437,7 @@ function getImportSpecifiers(node) {
 function getReferencedSymbol(typeChecker, node) {
 	let symbol;
 	const parent = node.parent;
-	if (isShorthandPropertyAssignment(parent)) symbol = typeChecker.getShorthandAssignmentValueSymbol(parent);
+	if (parent.kind === SyntaxKind.ShorthandPropertyAssignment) symbol = typeChecker.getShorthandAssignmentValueSymbol(parent);
 	else symbol = typeChecker.getSymbolAtLocation(node);
 	return symbol?.flags && (symbol.flags & SymbolFlags.Alias) !== 0 ? typeChecker.getAliasedSymbol(symbol) : symbol;
 }
@@ -20493,7 +20489,7 @@ function getTypeKeywordRange(node, sourceFile) {
 }
 function isInImportDeclaration(node) {
 	let current = node;
-	while (current) {
+	while (current.kind !== SyntaxKind.SourceFile) {
 		if (current.kind === SyntaxKind.ImportDeclaration) return true;
 		current = current.parent;
 	}
@@ -20508,8 +20504,8 @@ function isOnlyTypeReference(node) {
 	let parent = node.parent;
 	while (parent) {
 		if (parent.kind === SyntaxKind.HeritageClause) return parent.token === SyntaxKind.ImplementsKeyword;
-		if (parent.kind === SyntaxKind.TypeAliasDeclaration || parent.kind === SyntaxKind.InterfaceDeclaration || isTypeParameterDeclaration(parent)) return true;
-		if (isTypeNode(parent) && !isExpressionWithTypeArguments(parent)) return true;
+		if (parent.kind === SyntaxKind.TypeAliasDeclaration || parent.kind === SyntaxKind.InterfaceDeclaration || parent.kind === SyntaxKind.TypeParameter) return true;
+		if (isTypeNode(parent) && parent.kind !== SyntaxKind.ExpressionWithTypeArguments) return true;
 		current = parent;
 		parent = current.parent;
 	}
@@ -20876,23 +20872,23 @@ var unicodeBOMs_default = ruleCreator.createRule(typescriptLanguage, {
 //#region src/rules/unnecessaryBinds.ts
 function containsThis(node) {
 	if (node.kind === SyntaxKind.ThisKeyword) return true;
-	if (ts$1.isFunctionExpression(node) || ts$1.isFunctionDeclaration(node) || ts$1.isArrowFunction(node)) return false;
+	if (node.kind === SyntaxKind.FunctionExpression || node.kind === SyntaxKind.FunctionDeclaration || node.kind === SyntaxKind.ArrowFunction) return false;
 	let found = false;
-	node.forEachChild((child) => {
+	forEachChild(node, (child) => {
 		if (containsThis(child)) found = true;
 	});
 	return found;
 }
 function isStaticValue(node) {
-	if (ts$1.isParenthesizedExpression(node)) return isStaticValue(node.expression);
-	if (ts$1.isPrefixUnaryExpression(node)) return isStaticValue(node.operand);
-	if (ts$1.isIdentifier(node)) return true;
-	if (ts$1.isPropertyAccessExpression(node)) return isStaticValue(node.expression);
-	if (ts$1.isElementAccessExpression(node)) return isStaticValue(node.expression) && isStaticValue(node.argumentExpression);
-	return node.kind === SyntaxKind.ThisKeyword || node.kind === SyntaxKind.SuperKeyword || node.kind === SyntaxKind.TrueKeyword || node.kind === SyntaxKind.FalseKeyword || node.kind === SyntaxKind.NullKeyword || ts$1.isBigIntLiteral(node) || ts$1.isNumericLiteral(node) || ts$1.isStringLiteral(node) || ts$1.isNoSubstitutionTemplateLiteral(node) || node.kind === SyntaxKind.RegularExpressionLiteral;
+	if (node.kind === SyntaxKind.ParenthesizedExpression) return isStaticValue(node.expression);
+	if (node.kind === SyntaxKind.PrefixUnaryExpression) return isStaticValue(node.operand);
+	if (node.kind === SyntaxKind.Identifier) return true;
+	if (node.kind === SyntaxKind.PropertyAccessExpression) return isStaticValue(node.expression);
+	if (node.kind === SyntaxKind.ElementAccessExpression) return isStaticValue(node.expression) && isStaticValue(node.argumentExpression);
+	return node.kind === SyntaxKind.ThisKeyword || node.kind === SyntaxKind.SuperKeyword || node.kind === SyntaxKind.TrueKeyword || node.kind === SyntaxKind.FalseKeyword || node.kind === SyntaxKind.NullKeyword || node.kind === SyntaxKind.BigIntLiteral || node.kind === SyntaxKind.NumericLiteral || node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral || node.kind === SyntaxKind.RegularExpressionLiteral;
 }
 function unwrapParentheses(node) {
-	while (ts$1.isParenthesizedExpression(node)) node = node.expression;
+	while (node.kind === SyntaxKind.ParenthesizedExpression) node = node.expression;
 	return node;
 }
 var unnecessaryBinds_default = ruleCreator.createRule(typescriptLanguage, {
@@ -20922,7 +20918,7 @@ var unnecessaryBinds_default = ruleCreator.createRule(typescriptLanguage, {
 				range: getTSNodeRange(node, sourceFile),
 				text: node.expression.expression.getText(sourceFile)
 			} : void 0;
-			if (ts$1.isArrowFunction(boundFunction)) {
+			if (boundFunction.kind === SyntaxKind.ArrowFunction) {
 				context.report({
 					fix,
 					message: "arrowBind",
@@ -20933,7 +20929,7 @@ var unnecessaryBinds_default = ruleCreator.createRule(typescriptLanguage, {
 				});
 				return;
 			}
-			if (ts$1.isFunctionExpression(boundFunction) && !containsThis(boundFunction.body)) context.report({
+			if (boundFunction.kind === SyntaxKind.FunctionExpression && !containsThis(boundFunction.body)) context.report({
 				fix,
 				message: "unnecessaryBinds",
 				range: {