@flint.fyi/ts 0.23.1 → 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)
@@ -1686,9 +1686,7 @@ function isDirectEqualityCheck(node, operators, parameterName) {
 		case SyntaxKind.ArrowFunction:
 			body = node.body.kind === SyntaxKind.Block ? getDirectReturnExpression(node.body) : node.body;
 			break;
-		case SyntaxKind.FunctionExpression:
-			body = getDirectReturnExpression(node.body);
-			break;
+		case SyntaxKind.FunctionExpression: body = getDirectReturnExpression(node.body);
 	}
 	if (body?.kind !== SyntaxKind.BinaryExpression) return false;
 	const { left, operatorToken, right } = body;
@@ -2273,10 +2271,7 @@ var arrayTypes_default = ruleCreator.createRule(typescriptLanguage, {
 				if (node.parent.kind === SyntaxKind.TypeOperator && node.parent.operator === SyntaxKind.ReadonlyKeyword) return;
 				switch (options.style) {
 					case "array": return;
-					case "array-simple":
-						if (isSimpleType(node.elementType)) return;
-						break;
-					case "generic": break;
+					case "array-simple": if (isSimpleType(node.elementType)) return;
 				}
 				context.report({
 					message: "preferGenericSyntax",
@@ -2288,10 +2283,7 @@ var arrayTypes_default = ruleCreator.createRule(typescriptLanguage, {
 				const arrayType = node.type;
 				switch (options.style) {
 					case "array": return;
-					case "array-simple":
-						if (isSimpleType(arrayType.elementType)) return;
-						break;
-					case "generic": break;
+					case "array-simple": if (isSimpleType(arrayType.elementType)) return;
 				}
 				context.report({
 					message: "preferReadonlyGenericSyntax",
@@ -3024,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);
@@ -3053,9 +3048,7 @@ var catchCallbackTypes_default = ruleCreator.createRule(typescriptLanguage, {
 				case "catch":
 					if (node.arguments.length >= 1) checkCallbackParameter(node.arguments[0], sourceFile, typeChecker);
 					break;
-				case "then":
-					if (node.arguments.length >= 2) checkCallbackParameter(node.arguments[1], sourceFile, typeChecker);
-					break;
+				case "then": if (node.arguments.length >= 2) checkCallbackParameter(node.arguments[1], sourceFile, typeChecker);
 			}
 		} } };
 	}
@@ -3339,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) {
@@ -3437,9 +3428,7 @@ var classMethodsThis_default = ruleCreator.createRule(typescriptLanguage, {
 				case SyntaxKind.PropertyDeclaration:
 					checkPropertyInitializerFunction(member, node, sourceFile, options);
 					break;
-				case SyntaxKind.SetAccessor:
-					checkAccessor(member, node, sourceFile, options, "setter");
-					break;
+				case SyntaxKind.SetAccessor: checkAccessor(member, node, sourceFile, options, "setter");
 			}
 		}
 		return { visitors: {
@@ -3670,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);
@@ -3894,12 +3883,10 @@ var dateNowTimestamps_default = ruleCreator.createRule(typescriptLanguage, {
 							range: getTSNodeRange(node.parent, sourceFile)
 						});
 						break;
-					case SyntaxKind.PrefixUnaryExpression:
-						if (node.parent.operator === SyntaxKind.MinusToken || node.parent.operator === SyntaxKind.PlusToken) context.report({
-							message: "preferDateNow",
-							range: getTSNodeRange(node, sourceFile)
-						});
-						break;
+					case SyntaxKind.PrefixUnaryExpression: if (node.parent.operator === SyntaxKind.MinusToken || node.parent.operator === SyntaxKind.PlusToken) context.report({
+						message: "preferDateNow",
+						range: getTSNodeRange(node, sourceFile)
+					});
 				}
 			}
 		} };
@@ -4220,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;
@@ -4230,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;
@@ -4291,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, [{
@@ -4313,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,
@@ -4378,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: {
@@ -4394,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",
@@ -5244,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;
@@ -5389,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, {
@@ -5415,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;
@@ -5679,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);
@@ -5734,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;
@@ -5767,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;
@@ -5859,9 +5841,7 @@ var exportUniqueNames_default = ruleCreator.createRule(typescriptLanguage, {
 				case SyntaxKind.ExportDeclaration:
 					checkExportDeclaration(statement);
 					break;
-				case SyntaxKind.VariableStatement:
-					checkVariableStatement(statement);
-					break;
+				case SyntaxKind.VariableStatement: checkVariableStatement(statement);
 			}
 		} } };
 	}
@@ -6001,7 +5981,6 @@ var fetchMethodBodies_default = ruleCreator.createRule(typescriptLanguage, {
 						case "method":
 							if (property.initializer.kind !== SyntaxKind.StringLiteral) return;
 							methodText = property.initializer.text;
-							break;
 					}
 					break;
 				case SyntaxKind.SpreadAssignment: return;
@@ -6750,9 +6729,7 @@ function getCalleeName(node) {
 			if (node.expression.kind === SyntaxKind.Identifier && globalCandidates.has(node.expression.text) && node.argumentExpression.kind === SyntaxKind.StringLiteral) return node.argumentExpression.text;
 			break;
 		case SyntaxKind.Identifier: return node.text;
-		case SyntaxKind.PropertyAccessExpression:
-			if (node.expression.kind === SyntaxKind.Identifier && globalCandidates.has(node.expression.text)) return node.name.text;
-			break;
+		case SyntaxKind.PropertyAccessExpression: if (node.expression.kind === SyntaxKind.Identifier && globalCandidates.has(node.expression.text)) return node.name.text;
 	}
 }
 function isBind(node) {
@@ -6842,9 +6819,7 @@ var impliedEvals_default = ruleCreator.createRule(typescriptLanguage, {
 					checkCalleeFunction(node, services);
 					break;
 				case void 0: return;
-				default:
-					checkCalleeEval(node, calleeName, services);
-					break;
+				default: checkCalleeEval(node, calleeName, services);
 			}
 		}
 		return { visitors: {
@@ -7168,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;
 	}
 }
@@ -7195,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];
@@ -8418,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);
 }
@@ -8604,13 +8579,11 @@ var nonNullAssertionPlacement_default = ruleCreator.createRule(typescriptLanguag
 						suggestions
 					});
 					break;
-				default:
-					context.report({
-						message: "confusingEqual",
-						range,
-						suggestions
-					});
-					break;
+				default: context.report({
+					message: "confusingEqual",
+					range,
+					suggestions
+				});
 			}
 		} } };
 	}
@@ -9181,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: {
@@ -9254,12 +9227,10 @@ var numericErasingOperations_default = ruleCreator.createRule(typescriptLanguage
 						range: getTSNodeRange(node, sourceFile)
 					});
 					break;
-				case SyntaxKind.SlashToken:
-					if (isZeroLiteral(node.left) && !isZeroLiteral(node.right)) context.report({
-						message: "erasingOperation",
-						range: getTSNodeRange(node, sourceFile)
-					});
-					break;
+				case SyntaxKind.SlashToken: if (isZeroLiteral(node.left) && !isZeroLiteral(node.right)) context.report({
+					message: "erasingOperation",
+					range: getTSNodeRange(node, sourceFile)
+				});
 			}
 		} } };
 	}
@@ -10185,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"
 			};
@@ -10576,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;
 	}
@@ -11202,9 +11173,7 @@ function elementsToCharacterClass(elements) {
 		case "CharacterClassRange":
 		case "CharacterSet":
 		case "ClassStringDisjunction":
-		case "ExpressionCharacterClass":
-			parts.push(element.raw);
-			break;
+		case "ExpressionCharacterClass": parts.push(element.raw);
 	}
 	if (!parts.length) return "[]";
 	if (parts[0]?.[0] === "^") parts[0] = `\\${parts[0]}`;
@@ -11428,7 +11397,9 @@ function processCharacterClass(node) {
 		} else continue;
 		const group = groups.find((gp) => {
 			if (!(gp.min.value - 1 <= data.max.value && data.min.value <= gp.max.value + 1)) return false;
-			return inRange(ALPHANUMERIC_RANGES, Math.min(gp.min.value, data.min.value), Math.max(gp.max.value, data.max.value));
+			const min = Math.min(gp.min.value, data.min.value);
+			const max = Math.max(gp.max.value, data.max.value);
+			return inRange(ALPHANUMERIC_RANGES, min, max);
 		});
 		if (group) {
 			if (data.min.value < group.min.value) group.min = data.min;
@@ -12103,17 +12074,19 @@ function findIssues$2(pattern, flags) {
 		const groups = [];
 		for (const element of ccNode.elements) {
 			let data;
-			if (element.type === "Character") if (checkInAllowedRange(element.value)) data = {
-				max: element,
-				min: element
-			};
-			else continue;
-			else if (element.type === "CharacterClassRange") if (checkInAllowedRange(element.min.value, element.min.value, element.max.value)) data = {
-				max: element.max,
-				min: element.min
-			};
-			else continue;
-			else continue;
+			if (element.type === "Character") {
+				if (checkInAllowedRange(element.value)) data = {
+					max: element,
+					min: element
+				};
+				else continue;
+			} else if (element.type === "CharacterClassRange") {
+				if (checkInAllowedRange(element.min.value, element.min.value, element.max.value)) data = {
+					max: element.max,
+					min: element.min
+				};
+				else continue;
+			} else continue;
 			const group = groups.find((gp) => {
 				if (!(gp.min.value - 1 <= data.max.value && data.min.value <= gp.max.value + 1)) return false;
 				const min = Math.min(gp.min.value, data.min.value);
@@ -12456,9 +12429,10 @@ function findEmptyAlternativesInGroup(pattern, groupStart, groupEnd, results) {
 		"?!",
 		"?:",
 		"?="
-	].includes(pattern.slice(groupStart, groupStart + 2)) || ["?<!", "?<="].includes(pattern.slice(groupStart, groupStart + 3))) if (pattern.slice(groupStart, groupStart + 3).startsWith("?<")) contentStart = groupStart + 3;
-	else contentStart = groupStart + 2;
-	else if (pattern[groupStart] === "?" && pattern[groupStart + 1] === "<") {
+	].includes(pattern.slice(groupStart, groupStart + 2)) || ["?<!", "?<="].includes(pattern.slice(groupStart, groupStart + 3))) {
+		if (pattern.slice(groupStart, groupStart + 3).startsWith("?<")) contentStart = groupStart + 3;
+		else contentStart = groupStart + 2;
+	} else if (pattern[groupStart] === "?" && pattern[groupStart + 1] === "<") {
 		const closeAngle = pattern.indexOf(">", groupStart + 2);
 		if (closeAngle !== -1 && closeAngle < groupEnd) contentStart = closeAngle + 1;
 	}
@@ -12475,9 +12449,7 @@ function findEmptyAlternativesInGroup(pattern, groupStart, groupEnd, results) {
 		case "\\":
 			i++;
 			break;
-		case "|":
-			pipePositions.push(i);
-			break;
+		case "|": pipePositions.push(i);
 	}
 	if (!pipePositions.length) return;
 	const alternativeBoundaries = [];
@@ -12768,14 +12740,11 @@ function* extractLazyEndQuantifiers(alternatives) {
 			case "Group":
 				yield* extractLazyEndQuantifiers(last.alternatives);
 				break;
-			case "Quantifier":
-				if (!last.greedy && last.min !== last.max) yield last;
-				else if (last.max === 1) {
-					const element = last.element;
-					if (element.type === "Group" || element.type === "CapturingGroup") yield* extractLazyEndQuantifiers(element.alternatives);
-				}
-				break;
-			default: break;
+			case "Quantifier": if (!last.greedy && last.min !== last.max) yield last;
+			else if (last.max === 1) {
+				const element = last.element;
+				if (element.type === "Group" || element.type === "CapturingGroup") yield* extractLazyEndQuantifiers(element.alternatives);
+			}
 		}
 	}
 }
@@ -13233,9 +13202,10 @@ function simplifyCharacterClass(pattern, charClass) {
 	const elements = charClass.elements;
 	const keptCharacters = /* @__PURE__ */ new Set();
 	const rangesToKeep = [];
-	for (const element of elements) if (element.type === "Character") if (isLetter$1(element.value)) keptCharacters.add(toLowerCase(element.value));
-	else keptCharacters.add(element.value);
-	else if (element.type === "CharacterClassRange") {
+	for (const element of elements) if (element.type === "Character") {
+		if (isLetter$1(element.value)) keptCharacters.add(toLowerCase(element.value));
+		else keptCharacters.add(element.value);
+	} else if (element.type === "CharacterClassRange") {
 		const min = element.min.value;
 		const max = element.max.value;
 		const minIsUpper = min >= 65 && min <= 90;
@@ -13504,9 +13474,7 @@ function checkPattern(pattern, flags) {
 					checkHexadecimalEscape(charNode);
 					break;
 				case "unicode":
-				case "unicodeCodePoint":
-					checkUnicodeEscape(charNode);
-					break;
+				case "unicodeCodePoint": checkUnicodeEscape(charNode);
 			}
 		}
 	});
@@ -13602,9 +13570,7 @@ function escapeForRegexLiteral(pattern) {
 				result += char;
 				escaped = true;
 				break;
-			default:
-				result += char;
-				break;
+			default: result += char;
 		}
 	}
 	return result;
@@ -13816,9 +13782,7 @@ function* extractInvalidQuantifiers(alternatives, kind) {
 			case "Group":
 				yield* extractInvalidQuantifiers(last.alternatives, kind);
 				break;
-			case "Quantifier":
-				if (last.min !== last.max && !hasCapturingGroupDescendant(last.element)) yield last;
-				break;
+			case "Quantifier": if (last.min !== last.max && !hasCapturingGroupDescendant(last.element)) yield last;
 		}
 	}
 }
@@ -13933,17 +13897,14 @@ function isMatchAnyCharacterClass(node, flags) {
 				type: "CharacterSet"
 			});
 			break;
-		case "word":
-			if (element.negate) negativeElements.push({
-				kind: "word",
-				type: "CharacterSet"
-			});
-			else positiveElements.push({
-				kind: "word",
-				type: "CharacterSet"
-			});
-			break;
-		default: break;
+		case "word": if (element.negate) negativeElements.push({
+			kind: "word",
+			type: "CharacterSet"
+		});
+		else positiveElements.push({
+			kind: "word",
+			type: "CharacterSet"
+		});
 	}
 	else if (element.type === "CharacterClassRange" && element.min.value === 0 && (element.max.value === 65535 || element.max.value === 1114111 || flags.unicode && element.max.value >= 1114111)) return true;
 	for (const positive of positiveElements) if (negativeElements.find((negative) => negative.kind === positive.kind)) return true;
@@ -14376,12 +14337,15 @@ function* findZeroWidthJoins(characters) {
 	for (const [index, char] of characters.entries()) {
 		const previous = characters[index - 1];
 		const next = characters[index + 1];
-		if (previous && next && char.value === 8205 && previous.value !== 8205 && next.value !== 8205) if (sequence) if (sequence.at(-1) === previous) sequence.push(char, next);
-		else {
-			yield sequence;
-			sequence = characters.slice(index - 1, index + 2);
+		if (previous && next && char.value === 8205 && previous.value !== 8205 && next.value !== 8205) {
+			if (sequence) {
+				if (sequence.at(-1) === previous) sequence.push(char, next);
+				else {
+					yield sequence;
+					sequence = characters.slice(index - 1, index + 2);
+				}
+			} else sequence = characters.slice(index - 1, index + 2);
 		}
-		else sequence = characters.slice(index - 1, index + 2);
 	}
 	if (sequence) yield sequence;
 }
@@ -14429,7 +14393,6 @@ function* iterateCharacterSequence(nodes) {
 			sequence.push(node.min);
 			yield sequence;
 			sequence = [node.max];
-			break;
 	}
 	if (sequence.length) yield sequence;
 }
@@ -15262,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;
@@ -15345,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);
 			}
 		}
 	}
@@ -15353,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);
@@ -15363,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) {
@@ -15844,9 +15807,7 @@ function findReachableQuantifiers(pattern) {
 				case "Group":
 					for (const innerAlternative of element.alternatives) walkAlternative(innerAlternative);
 					break;
-				case "Quantifier":
-					if (element.max === Infinity && element.min === 0) quantifiers.push(element);
-					break;
+				case "Quantifier": if (element.max === Infinity && element.min === 0) quantifiers.push(element);
 			}
 			if (!canMatchEmpty(element)) return;
 		}
@@ -15865,19 +15826,15 @@ function generateAttackString(quantifier) {
 			if (first.type === "Character") character = String.fromCharCode(first.value);
 			break;
 		}
-		case "CharacterSet":
-			switch (quantifier.element.kind) {
-				case "any":
-					character = "x";
-					break;
-				case "digit":
-					character = "0";
-					break;
-				case "space":
-					character = " ";
-					break;
-			}
-			break;
+		case "CharacterSet": switch (quantifier.element.kind) {
+			case "any":
+				character = "x";
+				break;
+			case "digit":
+				character = "0";
+				break;
+			case "space": character = " ";
+		}
 	}
 	return (character ?? "a").repeat(20);
 }
@@ -17846,9 +17803,7 @@ function isOptionalAssertion(quantifierElement, assertion) {
 					}
 				}
 				break;
-			case "Quantifier":
-				if (parent !== quantifierElement && parent.max > 1 && canConsumeCharacters(parent.element)) return false;
-				break;
+			case "Quantifier": if (parent !== quantifierElement && parent.max > 1 && canConsumeCharacters(parent.element)) return false;
 		}
 		current = parent;
 	}
@@ -18906,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;
@@ -19309,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, {
@@ -19338,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)
@@ -19654,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;
@@ -20162,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;
@@ -20385,15 +20340,13 @@ var tsComments_default = ruleCreator.createRule(typescriptLanguage, {
 					case true:
 						reportCommentDirective(comment, directive, { directive }, "directiveComment", "preferExpectError");
 						return;
-					default:
-						if (typeof config === "object" && config.descriptionFormat) {
-							const format = descriptionFormats.get(directive);
-							if (format && !format.test(description)) reportCommentDirective(comment, directive, {
-								directive,
-								format: format.source
-							}, "descriptionNotMatchPattern");
-						}
-						break;
+					default: if (typeof config === "object" && config.descriptionFormat) {
+						const format = descriptionFormats.get(directive);
+						if (format && !format.test(description)) reportCommentDirective(comment, directive, {
+							directive,
+							format: format.source
+						}, "descriptionNotMatchPattern");
+					}
 				}
 			}
 		} } };
@@ -20475,14 +20428,16 @@ function getImportSpecifiers(node) {
 	const specifiers = [];
 	if (importClause.name) specifiers.push(importClause.name);
 	const namedBindings = importClause.namedBindings;
-	if (namedBindings) if (namedBindings.kind === SyntaxKind.NamespaceImport) specifiers.push(namedBindings);
-	else specifiers.push(...namedBindings.elements);
+	if (namedBindings) {
+		if (namedBindings.kind === SyntaxKind.NamespaceImport) specifiers.push(namedBindings);
+		else specifiers.push(...namedBindings.elements);
+	}
 	return specifiers;
 }
 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;
 }
@@ -20534,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;
 	}
@@ -20549,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;
 	}
@@ -20917,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, {
@@ -20963,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",
@@ -20974,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: {