// Code generated by tools/scripts/tsc/generate-ts-ast.ts. DO NOT EDIT.
import { SyntaxKind } from "../../enums/syntaxKind.js";
export function isToken(node) {
    return isTokenKind(node.kind);
}
isToken.Handle = isToken;
export function isIdentifier(node) {
    return node.kind === SyntaxKind.Identifier;
}
isIdentifier.Handle = isIdentifier;
export function isPrivateIdentifier(node) {
    return node.kind === SyntaxKind.PrivateIdentifier;
}
isPrivateIdentifier.Handle = isPrivateIdentifier;
export function isQualifiedName(node) {
    return node.kind === SyntaxKind.QualifiedName;
}
isQualifiedName.Handle = isQualifiedName;
export function isComputedPropertyName(node) {
    return node.kind === SyntaxKind.ComputedPropertyName;
}
isComputedPropertyName.Handle = isComputedPropertyName;
export function isDecorator(node) {
    return node.kind === SyntaxKind.Decorator;
}
isDecorator.Handle = isDecorator;
export function isEmptyStatement(node) {
    return node.kind === SyntaxKind.EmptyStatement;
}
isEmptyStatement.Handle = isEmptyStatement;
export function isIfStatement(node) {
    return node.kind === SyntaxKind.IfStatement;
}
isIfStatement.Handle = isIfStatement;
export function isDoStatement(node) {
    return node.kind === SyntaxKind.DoStatement;
}
isDoStatement.Handle = isDoStatement;
export function isWhileStatement(node) {
    return node.kind === SyntaxKind.WhileStatement;
}
isWhileStatement.Handle = isWhileStatement;
export function isForStatement(node) {
    return node.kind === SyntaxKind.ForStatement;
}
isForStatement.Handle = isForStatement;
export function isBreakStatement(node) {
    return node.kind === SyntaxKind.BreakStatement;
}
isBreakStatement.Handle = isBreakStatement;
export function isContinueStatement(node) {
    return node.kind === SyntaxKind.ContinueStatement;
}
isContinueStatement.Handle = isContinueStatement;
export function isReturnStatement(node) {
    return node.kind === SyntaxKind.ReturnStatement;
}
isReturnStatement.Handle = isReturnStatement;
export function isWithStatement(node) {
    return node.kind === SyntaxKind.WithStatement;
}
isWithStatement.Handle = isWithStatement;
export function isSwitchStatement(node) {
    return node.kind === SyntaxKind.SwitchStatement;
}
isSwitchStatement.Handle = isSwitchStatement;
export function isCaseBlock(node) {
    return node.kind === SyntaxKind.CaseBlock;
}
isCaseBlock.Handle = isCaseBlock;
export function isThrowStatement(node) {
    return node.kind === SyntaxKind.ThrowStatement;
}
isThrowStatement.Handle = isThrowStatement;
export function isTryStatement(node) {
    return node.kind === SyntaxKind.TryStatement;
}
isTryStatement.Handle = isTryStatement;
export function isCatchClause(node) {
    return node.kind === SyntaxKind.CatchClause;
}
isCatchClause.Handle = isCatchClause;
export function isDebuggerStatement(node) {
    return node.kind === SyntaxKind.DebuggerStatement;
}
isDebuggerStatement.Handle = isDebuggerStatement;
export function isLabeledStatement(node) {
    return node.kind === SyntaxKind.LabeledStatement;
}
isLabeledStatement.Handle = isLabeledStatement;
export function isExpressionStatement(node) {
    return node.kind === SyntaxKind.ExpressionStatement;
}
isExpressionStatement.Handle = isExpressionStatement;
export function isBlock(node) {
    return node.kind === SyntaxKind.Block;
}
isBlock.Handle = isBlock;
export function isVariableStatement(node) {
    return node.kind === SyntaxKind.VariableStatement;
}
isVariableStatement.Handle = isVariableStatement;
export function isVariableDeclaration(node) {
    return node.kind === SyntaxKind.VariableDeclaration;
}
isVariableDeclaration.Handle = isVariableDeclaration;
export function isVariableDeclarationList(node) {
    return node.kind === SyntaxKind.VariableDeclarationList;
}
isVariableDeclarationList.Handle = isVariableDeclarationList;
export function isParameterDeclaration(node) {
    return node.kind === SyntaxKind.Parameter;
}
isParameterDeclaration.Handle = isParameterDeclaration;
export function isBindingElement(node) {
    return node.kind === SyntaxKind.BindingElement;
}
isBindingElement.Handle = isBindingElement;
export function isMissingDeclaration(node) {
    return node.kind === SyntaxKind.MissingDeclaration;
}
isMissingDeclaration.Handle = isMissingDeclaration;
export function isFunctionDeclaration(node) {
    return node.kind === SyntaxKind.FunctionDeclaration;
}
isFunctionDeclaration.Handle = isFunctionDeclaration;
export function isClassDeclaration(node) {
    return node.kind === SyntaxKind.ClassDeclaration;
}
isClassDeclaration.Handle = isClassDeclaration;
export function isClassExpression(node) {
    return node.kind === SyntaxKind.ClassExpression;
}
isClassExpression.Handle = isClassExpression;
export function isHeritageClause(node) {
    return node.kind === SyntaxKind.HeritageClause;
}
isHeritageClause.Handle = isHeritageClause;
export function isInterfaceDeclaration(node) {
    return node.kind === SyntaxKind.InterfaceDeclaration;
}
isInterfaceDeclaration.Handle = isInterfaceDeclaration;
export function isTypeAliasDeclaration(node) {
    switch (node.kind) {
        case SyntaxKind.TypeAliasDeclaration:
        case SyntaxKind.JSTypeAliasDeclaration:
            return true;
        default:
            return false;
    }
}
isTypeAliasDeclaration.Handle = isTypeAliasDeclaration;
export function isEnumMember(node) {
    return node.kind === SyntaxKind.EnumMember;
}
isEnumMember.Handle = isEnumMember;
export function isEnumDeclaration(node) {
    return node.kind === SyntaxKind.EnumDeclaration;
}
isEnumDeclaration.Handle = isEnumDeclaration;
export function isModuleBlock(node) {
    return node.kind === SyntaxKind.ModuleBlock;
}
isModuleBlock.Handle = isModuleBlock;
export function isNotEmittedStatement(node) {
    return node.kind === SyntaxKind.NotEmittedStatement;
}
isNotEmittedStatement.Handle = isNotEmittedStatement;
export function isNotEmittedTypeElement(node) {
    return node.kind === SyntaxKind.NotEmittedTypeElement;
}
isNotEmittedTypeElement.Handle = isNotEmittedTypeElement;
export function isImportDeclaration(node) {
    switch (node.kind) {
        case SyntaxKind.ImportDeclaration:
        case SyntaxKind.JSImportDeclaration:
            return true;
        default:
            return false;
    }
}
isImportDeclaration.Handle = isImportDeclaration;
export function isExternalModuleReference(node) {
    return node.kind === SyntaxKind.ExternalModuleReference;
}
isExternalModuleReference.Handle = isExternalModuleReference;
export function isNamespaceImport(node) {
    return node.kind === SyntaxKind.NamespaceImport;
}
isNamespaceImport.Handle = isNamespaceImport;
export function isNamedImports(node) {
    return node.kind === SyntaxKind.NamedImports;
}
isNamedImports.Handle = isNamedImports;
export function isExportAssignment(node) {
    return node.kind === SyntaxKind.ExportAssignment;
}
isExportAssignment.Handle = isExportAssignment;
export function isNamespaceExportDeclaration(node) {
    return node.kind === SyntaxKind.NamespaceExportDeclaration;
}
isNamespaceExportDeclaration.Handle = isNamespaceExportDeclaration;
export function isNamespaceExport(node) {
    return node.kind === SyntaxKind.NamespaceExport;
}
isNamespaceExport.Handle = isNamespaceExport;
export function isNamedExports(node) {
    return node.kind === SyntaxKind.NamedExports;
}
isNamedExports.Handle = isNamedExports;
export function isExportSpecifier(node) {
    return node.kind === SyntaxKind.ExportSpecifier;
}
isExportSpecifier.Handle = isExportSpecifier;
export function isCallSignatureDeclaration(node) {
    return node.kind === SyntaxKind.CallSignature;
}
isCallSignatureDeclaration.Handle = isCallSignatureDeclaration;
export function isConstructSignatureDeclaration(node) {
    return node.kind === SyntaxKind.ConstructSignature;
}
isConstructSignatureDeclaration.Handle = isConstructSignatureDeclaration;
export function isConstructorDeclaration(node) {
    return node.kind === SyntaxKind.Constructor;
}
isConstructorDeclaration.Handle = isConstructorDeclaration;
export function isGetAccessorDeclaration(node) {
    return node.kind === SyntaxKind.GetAccessor;
}
isGetAccessorDeclaration.Handle = isGetAccessorDeclaration;
export function isSetAccessorDeclaration(node) {
    return node.kind === SyntaxKind.SetAccessor;
}
isSetAccessorDeclaration.Handle = isSetAccessorDeclaration;
export function isIndexSignatureDeclaration(node) {
    return node.kind === SyntaxKind.IndexSignature;
}
isIndexSignatureDeclaration.Handle = isIndexSignatureDeclaration;
export function isMethodSignatureDeclaration(node) {
    return node.kind === SyntaxKind.MethodSignature;
}
isMethodSignatureDeclaration.Handle = isMethodSignatureDeclaration;
export function isMethodDeclaration(node) {
    return node.kind === SyntaxKind.MethodDeclaration;
}
isMethodDeclaration.Handle = isMethodDeclaration;
export function isPropertySignatureDeclaration(node) {
    return node.kind === SyntaxKind.PropertySignature;
}
isPropertySignatureDeclaration.Handle = isPropertySignatureDeclaration;
export function isPropertyDeclaration(node) {
    return node.kind === SyntaxKind.PropertyDeclaration;
}
isPropertyDeclaration.Handle = isPropertyDeclaration;
export function isSemicolonClassElement(node) {
    return node.kind === SyntaxKind.SemicolonClassElement;
}
isSemicolonClassElement.Handle = isSemicolonClassElement;
export function isClassStaticBlockDeclaration(node) {
    return node.kind === SyntaxKind.ClassStaticBlockDeclaration;
}
isClassStaticBlockDeclaration.Handle = isClassStaticBlockDeclaration;
export function isOmittedExpression(node) {
    return node.kind === SyntaxKind.OmittedExpression;
}
isOmittedExpression.Handle = isOmittedExpression;
export function isKeywordExpression(node) {
    return isKeywordExpressionKind(node.kind);
}
isKeywordExpression.Handle = isKeywordExpression;
export function isStringLiteral(node) {
    return node.kind === SyntaxKind.StringLiteral;
}
isStringLiteral.Handle = isStringLiteral;
export function isNumericLiteral(node) {
    return node.kind === SyntaxKind.NumericLiteral;
}
isNumericLiteral.Handle = isNumericLiteral;
export function isBigIntLiteral(node) {
    return node.kind === SyntaxKind.BigIntLiteral;
}
isBigIntLiteral.Handle = isBigIntLiteral;
export function isRegularExpressionLiteral(node) {
    return node.kind === SyntaxKind.RegularExpressionLiteral;
}
isRegularExpressionLiteral.Handle = isRegularExpressionLiteral;
export function isNoSubstitutionTemplateLiteral(node) {
    return node.kind === SyntaxKind.NoSubstitutionTemplateLiteral;
}
isNoSubstitutionTemplateLiteral.Handle = isNoSubstitutionTemplateLiteral;
export function isBinaryExpression(node) {
    return node.kind === SyntaxKind.BinaryExpression;
}
isBinaryExpression.Handle = isBinaryExpression;
export function isPrefixUnaryExpression(node) {
    return node.kind === SyntaxKind.PrefixUnaryExpression;
}
isPrefixUnaryExpression.Handle = isPrefixUnaryExpression;
export function isPostfixUnaryExpression(node) {
    return node.kind === SyntaxKind.PostfixUnaryExpression;
}
isPostfixUnaryExpression.Handle = isPostfixUnaryExpression;
export function isYieldExpression(node) {
    return node.kind === SyntaxKind.YieldExpression;
}
isYieldExpression.Handle = isYieldExpression;
export function isArrowFunction(node) {
    return node.kind === SyntaxKind.ArrowFunction;
}
isArrowFunction.Handle = isArrowFunction;
export function isFunctionExpression(node) {
    return node.kind === SyntaxKind.FunctionExpression;
}
isFunctionExpression.Handle = isFunctionExpression;
export function isAsExpression(node) {
    return node.kind === SyntaxKind.AsExpression;
}
isAsExpression.Handle = isAsExpression;
export function isSatisfiesExpression(node) {
    return node.kind === SyntaxKind.SatisfiesExpression;
}
isSatisfiesExpression.Handle = isSatisfiesExpression;
export function isConditionalExpression(node) {
    return node.kind === SyntaxKind.ConditionalExpression;
}
isConditionalExpression.Handle = isConditionalExpression;
export function isPropertyAccessExpression(node) {
    return node.kind === SyntaxKind.PropertyAccessExpression;
}
isPropertyAccessExpression.Handle = isPropertyAccessExpression;
export function isElementAccessExpression(node) {
    return node.kind === SyntaxKind.ElementAccessExpression;
}
isElementAccessExpression.Handle = isElementAccessExpression;
export function isCallExpression(node) {
    return node.kind === SyntaxKind.CallExpression;
}
isCallExpression.Handle = isCallExpression;
export function isNewExpression(node) {
    return node.kind === SyntaxKind.NewExpression;
}
isNewExpression.Handle = isNewExpression;
export function isMetaProperty(node) {
    return node.kind === SyntaxKind.MetaProperty;
}
isMetaProperty.Handle = isMetaProperty;
export function isNonNullExpression(node) {
    return node.kind === SyntaxKind.NonNullExpression;
}
isNonNullExpression.Handle = isNonNullExpression;
export function isSpreadElement(node) {
    return node.kind === SyntaxKind.SpreadElement;
}
isSpreadElement.Handle = isSpreadElement;
export function isTemplateExpression(node) {
    return node.kind === SyntaxKind.TemplateExpression;
}
isTemplateExpression.Handle = isTemplateExpression;
export function isTemplateSpan(node) {
    return node.kind === SyntaxKind.TemplateSpan;
}
isTemplateSpan.Handle = isTemplateSpan;
export function isTaggedTemplateExpression(node) {
    return node.kind === SyntaxKind.TaggedTemplateExpression;
}
isTaggedTemplateExpression.Handle = isTaggedTemplateExpression;
export function isParenthesizedExpression(node) {
    return node.kind === SyntaxKind.ParenthesizedExpression;
}
isParenthesizedExpression.Handle = isParenthesizedExpression;
export function isArrayLiteralExpression(node) {
    return node.kind === SyntaxKind.ArrayLiteralExpression;
}
isArrayLiteralExpression.Handle = isArrayLiteralExpression;
export function isObjectLiteralExpression(node) {
    return node.kind === SyntaxKind.ObjectLiteralExpression;
}
isObjectLiteralExpression.Handle = isObjectLiteralExpression;
export function isSpreadAssignment(node) {
    return node.kind === SyntaxKind.SpreadAssignment;
}
isSpreadAssignment.Handle = isSpreadAssignment;
export function isPropertyAssignment(node) {
    return node.kind === SyntaxKind.PropertyAssignment;
}
isPropertyAssignment.Handle = isPropertyAssignment;
export function isShorthandPropertyAssignment(node) {
    return node.kind === SyntaxKind.ShorthandPropertyAssignment;
}
isShorthandPropertyAssignment.Handle = isShorthandPropertyAssignment;
export function isDeleteExpression(node) {
    return node.kind === SyntaxKind.DeleteExpression;
}
isDeleteExpression.Handle = isDeleteExpression;
export function isTypeOfExpression(node) {
    return node.kind === SyntaxKind.TypeOfExpression;
}
isTypeOfExpression.Handle = isTypeOfExpression;
export function isVoidExpression(node) {
    return node.kind === SyntaxKind.VoidExpression;
}
isVoidExpression.Handle = isVoidExpression;
export function isAwaitExpression(node) {
    return node.kind === SyntaxKind.AwaitExpression;
}
isAwaitExpression.Handle = isAwaitExpression;
export function isTypeAssertion(node) {
    return node.kind === SyntaxKind.TypeAssertionExpression;
}
isTypeAssertion.Handle = isTypeAssertion;
export function isKeywordTypeNode(node) {
    return isKeywordTypeKind(node.kind);
}
isKeywordTypeNode.Handle = isKeywordTypeNode;
export function isUnionTypeNode(node) {
    return node.kind === SyntaxKind.UnionType;
}
isUnionTypeNode.Handle = isUnionTypeNode;
export function isIntersectionTypeNode(node) {
    return node.kind === SyntaxKind.IntersectionType;
}
isIntersectionTypeNode.Handle = isIntersectionTypeNode;
export function isConditionalTypeNode(node) {
    return node.kind === SyntaxKind.ConditionalType;
}
isConditionalTypeNode.Handle = isConditionalTypeNode;
export function isTypeOperatorNode(node) {
    return node.kind === SyntaxKind.TypeOperator;
}
isTypeOperatorNode.Handle = isTypeOperatorNode;
export function isInferTypeNode(node) {
    return node.kind === SyntaxKind.InferType;
}
isInferTypeNode.Handle = isInferTypeNode;
export function isArrayTypeNode(node) {
    return node.kind === SyntaxKind.ArrayType;
}
isArrayTypeNode.Handle = isArrayTypeNode;
export function isIndexedAccessTypeNode(node) {
    return node.kind === SyntaxKind.IndexedAccessType;
}
isIndexedAccessTypeNode.Handle = isIndexedAccessTypeNode;
export function isTypeReferenceNode(node) {
    return node.kind === SyntaxKind.TypeReference;
}
isTypeReferenceNode.Handle = isTypeReferenceNode;
export function isExpressionWithTypeArguments(node) {
    return node.kind === SyntaxKind.ExpressionWithTypeArguments;
}
isExpressionWithTypeArguments.Handle = isExpressionWithTypeArguments;
export function isLiteralTypeNode(node) {
    return node.kind === SyntaxKind.LiteralType;
}
isLiteralTypeNode.Handle = isLiteralTypeNode;
export function isThisTypeNode(node) {
    return node.kind === SyntaxKind.ThisType;
}
isThisTypeNode.Handle = isThisTypeNode;
export function isTypePredicateNode(node) {
    return node.kind === SyntaxKind.TypePredicate;
}
isTypePredicateNode.Handle = isTypePredicateNode;
export function isImportAttribute(node) {
    return node.kind === SyntaxKind.ImportAttribute;
}
isImportAttribute.Handle = isImportAttribute;
export function isImportAttributes(node) {
    return node.kind === SyntaxKind.ImportAttributes;
}
isImportAttributes.Handle = isImportAttributes;
export function isTypeQueryNode(node) {
    return node.kind === SyntaxKind.TypeQuery;
}
isTypeQueryNode.Handle = isTypeQueryNode;
export function isMappedTypeNode(node) {
    return node.kind === SyntaxKind.MappedType;
}
isMappedTypeNode.Handle = isMappedTypeNode;
export function isTypeLiteralNode(node) {
    return node.kind === SyntaxKind.TypeLiteral;
}
isTypeLiteralNode.Handle = isTypeLiteralNode;
export function isTupleTypeNode(node) {
    return node.kind === SyntaxKind.TupleType;
}
isTupleTypeNode.Handle = isTupleTypeNode;
export function isNamedTupleMember(node) {
    return node.kind === SyntaxKind.NamedTupleMember;
}
isNamedTupleMember.Handle = isNamedTupleMember;
export function isOptionalTypeNode(node) {
    return node.kind === SyntaxKind.OptionalType;
}
isOptionalTypeNode.Handle = isOptionalTypeNode;
export function isRestTypeNode(node) {
    return node.kind === SyntaxKind.RestType;
}
isRestTypeNode.Handle = isRestTypeNode;
export function isParenthesizedTypeNode(node) {
    return node.kind === SyntaxKind.ParenthesizedType;
}
isParenthesizedTypeNode.Handle = isParenthesizedTypeNode;
export function isFunctionTypeNode(node) {
    return node.kind === SyntaxKind.FunctionType;
}
isFunctionTypeNode.Handle = isFunctionTypeNode;
export function isConstructorTypeNode(node) {
    return node.kind === SyntaxKind.ConstructorType;
}
isConstructorTypeNode.Handle = isConstructorTypeNode;
export function isTemplateHead(node) {
    return node.kind === SyntaxKind.TemplateHead;
}
isTemplateHead.Handle = isTemplateHead;
export function isTemplateMiddle(node) {
    return node.kind === SyntaxKind.TemplateMiddle;
}
isTemplateMiddle.Handle = isTemplateMiddle;
export function isTemplateTail(node) {
    return node.kind === SyntaxKind.TemplateTail;
}
isTemplateTail.Handle = isTemplateTail;
export function isTemplateLiteralTypeNode(node) {
    return node.kind === SyntaxKind.TemplateLiteralType;
}
isTemplateLiteralTypeNode.Handle = isTemplateLiteralTypeNode;
export function isTemplateLiteralTypeSpan(node) {
    return node.kind === SyntaxKind.TemplateLiteralTypeSpan;
}
isTemplateLiteralTypeSpan.Handle = isTemplateLiteralTypeSpan;
export function isSyntheticExpression(node) {
    return node.kind === SyntaxKind.SyntheticExpression;
}
isSyntheticExpression.Handle = isSyntheticExpression;
export function isPartiallyEmittedExpression(node) {
    return node.kind === SyntaxKind.PartiallyEmittedExpression;
}
isPartiallyEmittedExpression.Handle = isPartiallyEmittedExpression;
export function isJsxElement(node) {
    return node.kind === SyntaxKind.JsxElement;
}
isJsxElement.Handle = isJsxElement;
export function isJsxAttributes(node) {
    return node.kind === SyntaxKind.JsxAttributes;
}
isJsxAttributes.Handle = isJsxAttributes;
export function isJsxNamespacedName(node) {
    return node.kind === SyntaxKind.JsxNamespacedName;
}
isJsxNamespacedName.Handle = isJsxNamespacedName;
export function isJsxOpeningElement(node) {
    return node.kind === SyntaxKind.JsxOpeningElement;
}
isJsxOpeningElement.Handle = isJsxOpeningElement;
export function isJsxSelfClosingElement(node) {
    return node.kind === SyntaxKind.JsxSelfClosingElement;
}
isJsxSelfClosingElement.Handle = isJsxSelfClosingElement;
export function isJsxFragment(node) {
    return node.kind === SyntaxKind.JsxFragment;
}
isJsxFragment.Handle = isJsxFragment;
export function isJsxOpeningFragment(node) {
    return node.kind === SyntaxKind.JsxOpeningFragment;
}
isJsxOpeningFragment.Handle = isJsxOpeningFragment;
export function isJsxClosingFragment(node) {
    return node.kind === SyntaxKind.JsxClosingFragment;
}
isJsxClosingFragment.Handle = isJsxClosingFragment;
export function isJsxAttribute(node) {
    return node.kind === SyntaxKind.JsxAttribute;
}
isJsxAttribute.Handle = isJsxAttribute;
export function isJsxSpreadAttribute(node) {
    return node.kind === SyntaxKind.JsxSpreadAttribute;
}
isJsxSpreadAttribute.Handle = isJsxSpreadAttribute;
export function isJsxClosingElement(node) {
    return node.kind === SyntaxKind.JsxClosingElement;
}
isJsxClosingElement.Handle = isJsxClosingElement;
export function isJsxExpression(node) {
    return node.kind === SyntaxKind.JsxExpression;
}
isJsxExpression.Handle = isJsxExpression;
export function isJsxText(node) {
    return node.kind === SyntaxKind.JsxText;
}
isJsxText.Handle = isJsxText;
export function isSyntaxList(node) {
    return node.kind === SyntaxKind.SyntaxList;
}
isSyntaxList.Handle = isSyntaxList;
export function isJSDoc(node) {
    return node.kind === SyntaxKind.JSDoc;
}
isJSDoc.Handle = isJSDoc;
export function isJSDocTypeExpression(node) {
    return node.kind === SyntaxKind.JSDocTypeExpression;
}
isJSDocTypeExpression.Handle = isJSDocTypeExpression;
export function isJSDocNonNullableType(node) {
    return node.kind === SyntaxKind.JSDocNonNullableType;
}
isJSDocNonNullableType.Handle = isJSDocNonNullableType;
export function isJSDocNullableType(node) {
    return node.kind === SyntaxKind.JSDocNullableType;
}
isJSDocNullableType.Handle = isJSDocNullableType;
export function isJSDocAllType(node) {
    return node.kind === SyntaxKind.JSDocAllType;
}
isJSDocAllType.Handle = isJSDocAllType;
export function isJSDocVariadicType(node) {
    return node.kind === SyntaxKind.JSDocVariadicType;
}
isJSDocVariadicType.Handle = isJSDocVariadicType;
export function isJSDocOptionalType(node) {
    return node.kind === SyntaxKind.JSDocOptionalType;
}
isJSDocOptionalType.Handle = isJSDocOptionalType;
export function isJSDocTypeTag(node) {
    return node.kind === SyntaxKind.JSDocTypeTag;
}
isJSDocTypeTag.Handle = isJSDocTypeTag;
export function isJSDocUnknownTag(node) {
    return node.kind === SyntaxKind.JSDocUnknownTag;
}
isJSDocUnknownTag.Handle = isJSDocUnknownTag;
export function isJSDocTemplateTag(node) {
    return node.kind === SyntaxKind.JSDocTemplateTag;
}
isJSDocTemplateTag.Handle = isJSDocTemplateTag;
export function isJSDocReturnTag(node) {
    return node.kind === SyntaxKind.JSDocReturnTag;
}
isJSDocReturnTag.Handle = isJSDocReturnTag;
export function isJSDocPublicTag(node) {
    return node.kind === SyntaxKind.JSDocPublicTag;
}
isJSDocPublicTag.Handle = isJSDocPublicTag;
export function isJSDocPrivateTag(node) {
    return node.kind === SyntaxKind.JSDocPrivateTag;
}
isJSDocPrivateTag.Handle = isJSDocPrivateTag;
export function isJSDocProtectedTag(node) {
    return node.kind === SyntaxKind.JSDocProtectedTag;
}
isJSDocProtectedTag.Handle = isJSDocProtectedTag;
export function isJSDocReadonlyTag(node) {
    return node.kind === SyntaxKind.JSDocReadonlyTag;
}
isJSDocReadonlyTag.Handle = isJSDocReadonlyTag;
export function isJSDocOverrideTag(node) {
    return node.kind === SyntaxKind.JSDocOverrideTag;
}
isJSDocOverrideTag.Handle = isJSDocOverrideTag;
export function isJSDocDeprecatedTag(node) {
    return node.kind === SyntaxKind.JSDocDeprecatedTag;
}
isJSDocDeprecatedTag.Handle = isJSDocDeprecatedTag;
export function isJSDocSeeTag(node) {
    return node.kind === SyntaxKind.JSDocSeeTag;
}
isJSDocSeeTag.Handle = isJSDocSeeTag;
export function isJSDocImplementsTag(node) {
    return node.kind === SyntaxKind.JSDocImplementsTag;
}
isJSDocImplementsTag.Handle = isJSDocImplementsTag;
export function isJSDocAugmentsTag(node) {
    return node.kind === SyntaxKind.JSDocAugmentsTag;
}
isJSDocAugmentsTag.Handle = isJSDocAugmentsTag;
export function isJSDocSatisfiesTag(node) {
    return node.kind === SyntaxKind.JSDocSatisfiesTag;
}
isJSDocSatisfiesTag.Handle = isJSDocSatisfiesTag;
export function isJSDocThrowsTag(node) {
    return node.kind === SyntaxKind.JSDocThrowsTag;
}
isJSDocThrowsTag.Handle = isJSDocThrowsTag;
export function isJSDocThisTag(node) {
    return node.kind === SyntaxKind.JSDocThisTag;
}
isJSDocThisTag.Handle = isJSDocThisTag;
export function isJSDocImportTag(node) {
    return node.kind === SyntaxKind.JSDocImportTag;
}
isJSDocImportTag.Handle = isJSDocImportTag;
export function isJSDocCallbackTag(node) {
    return node.kind === SyntaxKind.JSDocCallbackTag;
}
isJSDocCallbackTag.Handle = isJSDocCallbackTag;
export function isJSDocOverloadTag(node) {
    return node.kind === SyntaxKind.JSDocOverloadTag;
}
isJSDocOverloadTag.Handle = isJSDocOverloadTag;
export function isJSDocTypedefTag(node) {
    return node.kind === SyntaxKind.JSDocTypedefTag;
}
isJSDocTypedefTag.Handle = isJSDocTypedefTag;
export function isJSDocSignature(node) {
    return node.kind === SyntaxKind.JSDocSignature;
}
isJSDocSignature.Handle = isJSDocSignature;
export function isJSDocNameReference(node) {
    return node.kind === SyntaxKind.JSDocNameReference;
}
isJSDocNameReference.Handle = isJSDocNameReference;
export function isSourceFile(node) {
    return node.kind === SyntaxKind.SourceFile;
}
isSourceFile.Handle = isSourceFile;
export function isModuleDeclaration(node) {
    return node.kind === SyntaxKind.ModuleDeclaration;
}
isModuleDeclaration.Handle = isModuleDeclaration;
export function isImportEqualsDeclaration(node) {
    return node.kind === SyntaxKind.ImportEqualsDeclaration;
}
isImportEqualsDeclaration.Handle = isImportEqualsDeclaration;
export function isExportDeclaration(node) {
    return node.kind === SyntaxKind.ExportDeclaration;
}
isExportDeclaration.Handle = isExportDeclaration;
export function isImportTypeNode(node) {
    return node.kind === SyntaxKind.ImportType;
}
isImportTypeNode.Handle = isImportTypeNode;
export function isImportClause(node) {
    return node.kind === SyntaxKind.ImportClause;
}
isImportClause.Handle = isImportClause;
export function isImportSpecifier(node) {
    return node.kind === SyntaxKind.ImportSpecifier;
}
isImportSpecifier.Handle = isImportSpecifier;
export function isJSDocText(node) {
    return node.kind === SyntaxKind.JSDocText;
}
isJSDocText.Handle = isJSDocText;
export function isJSDocLink(node) {
    return node.kind === SyntaxKind.JSDocLink;
}
isJSDocLink.Handle = isJSDocLink;
export function isJSDocLinkPlain(node) {
    return node.kind === SyntaxKind.JSDocLinkPlain;
}
isJSDocLinkPlain.Handle = isJSDocLinkPlain;
export function isJSDocLinkCode(node) {
    return node.kind === SyntaxKind.JSDocLinkCode;
}
isJSDocLinkCode.Handle = isJSDocLinkCode;
export function isTypeParameterDeclaration(node) {
    return node.kind === SyntaxKind.TypeParameter;
}
isTypeParameterDeclaration.Handle = isTypeParameterDeclaration;
export function isSyntheticReferenceExpression(node) {
    return node.kind === SyntaxKind.SyntheticReferenceExpression;
}
isSyntheticReferenceExpression.Handle = isSyntheticReferenceExpression;
export function isJSDocTypeLiteral(node) {
    return node.kind === SyntaxKind.JSDocTypeLiteral;
}
isJSDocTypeLiteral.Handle = isJSDocTypeLiteral;
export function isForInStatement(node) {
    return node.kind === SyntaxKind.ForInStatement;
}
isForInStatement.Handle = isForInStatement;
export function isForOfStatement(node) {
    return node.kind === SyntaxKind.ForOfStatement;
}
isForOfStatement.Handle = isForOfStatement;
export function isCaseClause(node) {
    return node.kind === SyntaxKind.CaseClause;
}
isCaseClause.Handle = isCaseClause;
export function isDefaultClause(node) {
    return node.kind === SyntaxKind.DefaultClause;
}
isDefaultClause.Handle = isDefaultClause;
export function isObjectBindingPattern(node) {
    return node.kind === SyntaxKind.ObjectBindingPattern;
}
isObjectBindingPattern.Handle = isObjectBindingPattern;
export function isArrayBindingPattern(node) {
    return node.kind === SyntaxKind.ArrayBindingPattern;
}
isArrayBindingPattern.Handle = isArrayBindingPattern;
export function isJSDocParameterTag(node) {
    return node.kind === SyntaxKind.JSDocParameterTag;
}
isJSDocParameterTag.Handle = isJSDocParameterTag;
export function isJSDocPropertyTag(node) {
    return node.kind === SyntaxKind.JSDocPropertyTag;
}
isJSDocPropertyTag.Handle = isJSDocPropertyTag;
export function isHeritageClauseElement(node) {
    return node.kind === SyntaxKind.ExpressionWithTypeArguments || node.kind === SyntaxKind.TypeReference;
}
isHeritageClauseElement.Handle = isHeritageClauseElement;
export function isAccessExpression(node) {
    return node.kind === SyntaxKind.PropertyAccessExpression || node.kind === SyntaxKind.ElementAccessExpression;
}
isAccessExpression.Handle = isAccessExpression;
export function isDeclarationName(node) {
    const kind = node.kind;
    return kind === SyntaxKind.Identifier || kind === SyntaxKind.PrivateIdentifier || kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.BigIntLiteral || kind === SyntaxKind.NoSubstitutionTemplateLiteral || kind === SyntaxKind.ComputedPropertyName || kind === SyntaxKind.ObjectBindingPattern || kind === SyntaxKind.ArrayBindingPattern || kind === SyntaxKind.PropertyAccessExpression || kind === SyntaxKind.ElementAccessExpression;
}
isDeclarationName.Handle = isDeclarationName;
export function isModuleName(node) {
    return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.StringLiteral;
}
isModuleName.Handle = isModuleName;
export function isModuleExportName(node) {
    return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.StringLiteral;
}
isModuleExportName.Handle = isModuleExportName;
export function isPropertyName(node) {
    const kind = node.kind;
    return kind === SyntaxKind.Identifier || kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NoSubstitutionTemplateLiteral || kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.ComputedPropertyName || kind === SyntaxKind.PrivateIdentifier || kind === SyntaxKind.BigIntLiteral;
}
isPropertyName.Handle = isPropertyName;
export function isModuleBody(node) {
    return node.kind === SyntaxKind.ModuleBlock || node.kind === SyntaxKind.ModuleDeclaration;
}
isModuleBody.Handle = isModuleBody;
export function isJSDocFullName(node) {
    return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.ModuleDeclaration;
}
isJSDocFullName.Handle = isJSDocFullName;
export function isModuleReference(node) {
    return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName || node.kind === SyntaxKind.ExternalModuleReference;
}
isModuleReference.Handle = isModuleReference;
export function isNamedImportBindings(node) {
    return node.kind === SyntaxKind.NamespaceImport || node.kind === SyntaxKind.NamedImports;
}
isNamedImportBindings.Handle = isNamedImportBindings;
export function isNamedExportBindings(node) {
    return node.kind === SyntaxKind.NamespaceExport || node.kind === SyntaxKind.NamedExports;
}
isNamedExportBindings.Handle = isNamedExportBindings;
export function isMemberName(node) {
    return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.PrivateIdentifier;
}
isMemberName.Handle = isMemberName;
export function isEntityName(node) {
    return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName;
}
isEntityName.Handle = isEntityName;
export function isBindingName(node) {
    return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.ObjectBindingPattern || node.kind === SyntaxKind.ArrayBindingPattern;
}
isBindingName.Handle = isBindingName;
export function isModifierLike(node) {
    const kind = node.kind;
    return kind === SyntaxKind.AbstractKeyword || kind === SyntaxKind.AccessorKeyword || kind === SyntaxKind.AsyncKeyword || kind === SyntaxKind.ConstKeyword || kind === SyntaxKind.DeclareKeyword || kind === SyntaxKind.DefaultKeyword || kind === SyntaxKind.ExportKeyword || kind === SyntaxKind.InKeyword || kind === SyntaxKind.PrivateKeyword || kind === SyntaxKind.ProtectedKeyword || kind === SyntaxKind.PublicKeyword || kind === SyntaxKind.ReadonlyKeyword || kind === SyntaxKind.OutKeyword || kind === SyntaxKind.OverrideKeyword || kind === SyntaxKind.StaticKeyword || kind === SyntaxKind.Decorator;
}
isModifierLike.Handle = isModifierLike;
export function isJsxChild(node) {
    const kind = node.kind;
    return kind === SyntaxKind.JsxText || kind === SyntaxKind.JsxExpression || kind === SyntaxKind.JsxElement || kind === SyntaxKind.JsxSelfClosingElement || kind === SyntaxKind.JsxFragment;
}
isJsxChild.Handle = isJsxChild;
export function isJsxAttributeLike(node) {
    return node.kind === SyntaxKind.JsxAttribute || node.kind === SyntaxKind.JsxSpreadAttribute;
}
isJsxAttributeLike.Handle = isJsxAttributeLike;
export function isJsxAttributeName(node) {
    return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.JsxNamespacedName;
}
isJsxAttributeName.Handle = isJsxAttributeName;
export function isJsxAttributeValue(node) {
    const kind = node.kind;
    return kind === SyntaxKind.StringLiteral || kind === SyntaxKind.JsxExpression || kind === SyntaxKind.JsxElement || kind === SyntaxKind.JsxSelfClosingElement || kind === SyntaxKind.JsxFragment;
}
isJsxAttributeValue.Handle = isJsxAttributeValue;
export function isClassLikeDeclaration(node) {
    return node.kind === SyntaxKind.ClassDeclaration || node.kind === SyntaxKind.ClassExpression;
}
isClassLikeDeclaration.Handle = isClassLikeDeclaration;
export function isAccessorDeclaration(node) {
    return node.kind === SyntaxKind.GetAccessor || node.kind === SyntaxKind.SetAccessor;
}
isAccessorDeclaration.Handle = isAccessorDeclaration;
export function isLiteralLikeNode(node) {
    const kind = node.kind;
    return kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.BigIntLiteral || kind === SyntaxKind.RegularExpressionLiteral || kind === SyntaxKind.TemplateHead || kind === SyntaxKind.TemplateMiddle || kind === SyntaxKind.TemplateTail || kind === SyntaxKind.JsxText;
}
isLiteralLikeNode.Handle = isLiteralLikeNode;
export function isLiteralExpression(node) {
    const kind = node.kind;
    return kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.BigIntLiteral || kind === SyntaxKind.RegularExpressionLiteral || kind === SyntaxKind.NoSubstitutionTemplateLiteral;
}
isLiteralExpression.Handle = isLiteralExpression;
export function isUnionOrIntersectionTypeNode(node) {
    return node.kind === SyntaxKind.UnionType || node.kind === SyntaxKind.IntersectionType;
}
isUnionOrIntersectionTypeNode.Handle = isUnionOrIntersectionTypeNode;
export function isTemplateLiteralLikeNode(node) {
    const kind = node.kind;
    return isPseudoLiteralKind(kind);
}
isTemplateLiteralLikeNode.Handle = isTemplateLiteralLikeNode;
export function isTemplateMiddleOrTail(node) {
    return node.kind === SyntaxKind.TemplateMiddle || node.kind === SyntaxKind.TemplateTail;
}
isTemplateMiddleOrTail.Handle = isTemplateMiddleOrTail;
export function isTemplateLiteral(node) {
    return node.kind === SyntaxKind.TemplateExpression || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral;
}
isTemplateLiteral.Handle = isTemplateLiteral;
export function isTypePredicateParameterName(node) {
    return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.ThisType;
}
isTypePredicateParameterName.Handle = isTypePredicateParameterName;
export function isImportAttributeName(node) {
    return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.StringLiteral;
}
isImportAttributeName.Handle = isImportAttributeName;
export function isJSDocComment(node) {
    const kind = node.kind;
    return kind === SyntaxKind.JSDocText || kind === SyntaxKind.JSDocLink || kind === SyntaxKind.JSDocLinkCode || kind === SyntaxKind.JSDocLinkPlain;
}
isJSDocComment.Handle = isJSDocComment;
export function isSignatureDeclaration(node) {
    const kind = node.kind;
    return kind === SyntaxKind.CallSignature || kind === SyntaxKind.ConstructSignature || kind === SyntaxKind.MethodSignature || kind === SyntaxKind.IndexSignature || kind === SyntaxKind.FunctionType || kind === SyntaxKind.ConstructorType || kind === SyntaxKind.FunctionDeclaration || kind === SyntaxKind.MethodDeclaration || kind === SyntaxKind.Constructor || kind === SyntaxKind.GetAccessor || kind === SyntaxKind.SetAccessor || kind === SyntaxKind.FunctionExpression || kind === SyntaxKind.ArrowFunction;
}
isSignatureDeclaration.Handle = isSignatureDeclaration;
export function isStringLiteralLikeNode(node) {
    return node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral;
}
isStringLiteralLikeNode.Handle = isStringLiteralLikeNode;
export function isNumericOrStringLikeLiteral(node) {
    return node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral || node.kind === SyntaxKind.NumericLiteral;
}
isNumericOrStringLikeLiteral.Handle = isNumericOrStringLikeLiteral;
export function isObjectLiteralLikeNode(node) {
    return node.kind === SyntaxKind.ObjectLiteralExpression || node.kind === SyntaxKind.ObjectBindingPattern;
}
isObjectLiteralLikeNode.Handle = isObjectLiteralLikeNode;
export function isObjectTypeDeclaration(node) {
    const kind = node.kind;
    return kind === SyntaxKind.ClassDeclaration || kind === SyntaxKind.ClassExpression || kind === SyntaxKind.InterfaceDeclaration || kind === SyntaxKind.TypeLiteral;
}
isObjectTypeDeclaration.Handle = isObjectTypeDeclaration;
export function isJsxOpeningLikeElement(node) {
    return node.kind === SyntaxKind.JsxOpeningElement || node.kind === SyntaxKind.JsxSelfClosingElement;
}
isJsxOpeningLikeElement.Handle = isJsxOpeningLikeElement;
export function isNamedImportsOrExports(node) {
    return node.kind === SyntaxKind.NamedImports || node.kind === SyntaxKind.NamedExports;
}
isNamedImportsOrExports.Handle = isNamedImportsOrExports;
export function isBreakOrContinueStatement(node) {
    return node.kind === SyntaxKind.BreakStatement || node.kind === SyntaxKind.ContinueStatement;
}
isBreakOrContinueStatement.Handle = isBreakOrContinueStatement;
export function isCallLikeExpression(node) {
    const kind = node.kind;
    return kind === SyntaxKind.CallExpression || kind === SyntaxKind.NewExpression || kind === SyntaxKind.TaggedTemplateExpression || kind === SyntaxKind.Decorator || kind === SyntaxKind.JsxOpeningElement || kind === SyntaxKind.JsxSelfClosingElement || kind === SyntaxKind.BinaryExpression;
}
isCallLikeExpression.Handle = isCallLikeExpression;
export function isFunctionLikeDeclaration(node) {
    const kind = node.kind;
    return kind === SyntaxKind.FunctionDeclaration || kind === SyntaxKind.MethodDeclaration || kind === SyntaxKind.GetAccessor || kind === SyntaxKind.SetAccessor || kind === SyntaxKind.Constructor || kind === SyntaxKind.FunctionExpression || kind === SyntaxKind.ArrowFunction;
}
isFunctionLikeDeclaration.Handle = isFunctionLikeDeclaration;
export function isVariableOrParameterDeclaration(node) {
    return node.kind === SyntaxKind.VariableDeclaration || node.kind === SyntaxKind.Parameter;
}
isVariableOrParameterDeclaration.Handle = isVariableOrParameterDeclaration;
export function isVariableOrPropertyDeclaration(node) {
    return node.kind === SyntaxKind.VariableDeclaration || node.kind === SyntaxKind.PropertyDeclaration;
}
isVariableOrPropertyDeclaration.Handle = isVariableOrPropertyDeclaration;
export function isCallOrNewExpression(node) {
    return node.kind === SyntaxKind.CallExpression || node.kind === SyntaxKind.NewExpression;
}
isCallOrNewExpression.Handle = isCallOrNewExpression;
export function isImportClauseOrBindingPattern(node) {
    return node.kind === SyntaxKind.ImportClause || node.kind === SyntaxKind.ObjectBindingPattern || node.kind === SyntaxKind.ArrayBindingPattern;
}
isImportClauseOrBindingPattern.Handle = isImportClauseOrBindingPattern;
export function isAnyImportSyntax(node) {
    return node.kind === SyntaxKind.ImportDeclaration || node.kind === SyntaxKind.JSImportDeclaration || node.kind === SyntaxKind.ImportEqualsDeclaration;
}
isAnyImportSyntax.Handle = isAnyImportSyntax;
export function isArrayBindingElement(node) {
    return node.kind === SyntaxKind.BindingElement || node.kind === SyntaxKind.OmittedExpression;
}
isArrayBindingElement.Handle = isArrayBindingElement;
export function isAssertionExpression(node) {
    return node.kind === SyntaxKind.TypeAssertionExpression || node.kind === SyntaxKind.AsExpression;
}
isAssertionExpression.Handle = isAssertionExpression;
export function isBooleanLiteral(node) {
    return node.kind === SyntaxKind.TrueKeyword || node.kind === SyntaxKind.FalseKeyword;
}
isBooleanLiteral.Handle = isBooleanLiteral;
export function isDestructuringAssignment(node) {
    return node.kind === SyntaxKind.BinaryExpression;
}
isDestructuringAssignment.Handle = isDestructuringAssignment;
export function isLiteralToken(node) {
    const kind = node.kind;
    return kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.BigIntLiteral || kind === SyntaxKind.StringLiteral || kind === SyntaxKind.JsxText || kind === SyntaxKind.RegularExpressionLiteral || kind === SyntaxKind.NoSubstitutionTemplateLiteral;
}
isLiteralToken.Handle = isLiteralToken;
export function isModifier(node) {
    const kind = node.kind;
    return isModifierKind(kind);
}
isModifier.Handle = isModifier;
export function isObjectLiteralElementLike(node) {
    const kind = node.kind;
    return kind === SyntaxKind.PropertyAssignment || kind === SyntaxKind.ShorthandPropertyAssignment || kind === SyntaxKind.SpreadAssignment || kind === SyntaxKind.MethodDeclaration || kind === SyntaxKind.GetAccessor || kind === SyntaxKind.SetAccessor;
}
isObjectLiteralElementLike.Handle = isObjectLiteralElementLike;
export function isPropertyNameLiteral(node) {
    return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NumericLiteral;
}
isPropertyNameLiteral.Handle = isPropertyNameLiteral;
export function isPseudoLiteralToken(node) {
    const kind = node.kind;
    return isPseudoLiteralKind(kind);
}
isPseudoLiteralToken.Handle = isPseudoLiteralToken;
export function isTemplateLiteralToken(node) {
    const kind = node.kind;
    return kind === SyntaxKind.NoSubstitutionTemplateLiteral || kind === SyntaxKind.TemplateHead || kind === SyntaxKind.TemplateMiddle || kind === SyntaxKind.TemplateTail;
}
isTemplateLiteralToken.Handle = isTemplateLiteralToken;
export function isArrayDestructuringAssignment(node) {
    return node.kind === SyntaxKind.BinaryExpression;
}
isArrayDestructuringAssignment.Handle = isArrayDestructuringAssignment;
export function isObjectDestructuringAssignment(node) {
    return node.kind === SyntaxKind.BinaryExpression;
}
isObjectDestructuringAssignment.Handle = isObjectDestructuringAssignment;
export function isFunctionBody(node) {
    return node.kind === SyntaxKind.Block;
}
isFunctionBody.Handle = isFunctionBody;
export function isTriviaKind(kind) {
    return kind === SyntaxKind.SingleLineCommentTrivia
        || kind === SyntaxKind.MultiLineCommentTrivia
        || kind === SyntaxKind.NewLineTrivia
        || kind === SyntaxKind.WhitespaceTrivia
        || kind === SyntaxKind.ConflictMarkerTrivia;
}
export function isPseudoLiteralKind(kind) {
    return kind === SyntaxKind.TemplateHead
        || kind === SyntaxKind.TemplateMiddle
        || kind === SyntaxKind.TemplateTail;
}
export function isModifierKind(kind) {
    return kind === SyntaxKind.AbstractKeyword
        || kind === SyntaxKind.AccessorKeyword
        || kind === SyntaxKind.AsyncKeyword
        || kind === SyntaxKind.ConstKeyword
        || kind === SyntaxKind.DeclareKeyword
        || kind === SyntaxKind.DefaultKeyword
        || kind === SyntaxKind.ExportKeyword
        || kind === SyntaxKind.InKeyword
        || kind === SyntaxKind.PrivateKeyword
        || kind === SyntaxKind.ProtectedKeyword
        || kind === SyntaxKind.PublicKeyword
        || kind === SyntaxKind.ReadonlyKeyword
        || kind === SyntaxKind.OutKeyword
        || kind === SyntaxKind.OverrideKeyword
        || kind === SyntaxKind.StaticKeyword;
}
export function isKeywordTypeKind(kind) {
    return kind === SyntaxKind.AnyKeyword
        || kind === SyntaxKind.BigIntKeyword
        || kind === SyntaxKind.BooleanKeyword
        || kind === SyntaxKind.IntrinsicKeyword
        || kind === SyntaxKind.NeverKeyword
        || kind === SyntaxKind.NumberKeyword
        || kind === SyntaxKind.ObjectKeyword
        || kind === SyntaxKind.StringKeyword
        || kind === SyntaxKind.SymbolKeyword
        || kind === SyntaxKind.UndefinedKeyword
        || kind === SyntaxKind.UnknownKeyword
        || kind === SyntaxKind.VoidKeyword;
}
export function isKeywordExpressionKind(kind) {
    return kind === SyntaxKind.NullKeyword
        || kind === SyntaxKind.TrueKeyword
        || kind === SyntaxKind.FalseKeyword
        || kind === SyntaxKind.ThisKeyword
        || kind === SyntaxKind.SuperKeyword
        || kind === SyntaxKind.ImportKeyword;
}
export function isJsxTokenKind(kind) {
    return kind === SyntaxKind.LessThanSlashToken
        || kind === SyntaxKind.EndOfFile
        || kind === SyntaxKind.ConflictMarkerTrivia
        || kind === SyntaxKind.JsxText
        || kind === SyntaxKind.JsxTextAllWhiteSpaces
        || kind === SyntaxKind.OpenBraceToken
        || kind === SyntaxKind.LessThanToken;
}
export function isImportPhaseModifierKind(kind) {
    return kind === SyntaxKind.TypeKeyword
        || kind === SyntaxKind.DeferKeyword
        || kind === SyntaxKind.SourceKeyword;
}
export function isPostfixUnaryOperator(kind) {
    return kind === SyntaxKind.PlusPlusToken
        || kind === SyntaxKind.MinusMinusToken;
}
export function isPrefixUnaryOperator(kind) {
    return kind === SyntaxKind.PlusToken
        || kind === SyntaxKind.MinusToken
        || kind === SyntaxKind.TildeToken
        || kind === SyntaxKind.ExclamationToken
        || kind === SyntaxKind.PlusPlusToken
        || kind === SyntaxKind.MinusMinusToken;
}
export function isAssignmentOperator(kind) {
    return kind === SyntaxKind.EqualsToken
        || isCompoundAssignmentOperator(kind);
}
export function isBinaryOperator(kind) {
    return isAssignmentOperatorOrHigher(kind)
        || kind === SyntaxKind.CommaToken;
}
export function isExponentiationOperator(kind) {
    return kind === SyntaxKind.AsteriskAsteriskToken;
}
export function isMultiplicativeOperator(kind) {
    return kind === SyntaxKind.AsteriskToken
        || kind === SyntaxKind.SlashToken
        || kind === SyntaxKind.PercentToken;
}
export function isMultiplicativeOperatorOrHigher(kind) {
    return isExponentiationOperator(kind)
        || isMultiplicativeOperator(kind);
}
export function isAdditiveOperator(kind) {
    return kind === SyntaxKind.PlusToken
        || kind === SyntaxKind.MinusToken;
}
export function isAdditiveOperatorOrHigher(kind) {
    return isMultiplicativeOperatorOrHigher(kind)
        || isAdditiveOperator(kind);
}
export function isShiftOperator(kind) {
    return kind === SyntaxKind.LessThanLessThanToken
        || kind === SyntaxKind.GreaterThanGreaterThanToken
        || kind === SyntaxKind.GreaterThanGreaterThanGreaterThanToken;
}
export function isShiftOperatorOrHigher(kind) {
    return isAdditiveOperatorOrHigher(kind)
        || isShiftOperator(kind);
}
export function isRelationalOperator(kind) {
    return kind === SyntaxKind.LessThanToken
        || kind === SyntaxKind.LessThanEqualsToken
        || kind === SyntaxKind.GreaterThanToken
        || kind === SyntaxKind.GreaterThanEqualsToken
        || kind === SyntaxKind.InstanceOfKeyword
        || kind === SyntaxKind.InKeyword;
}
export function isRelationalOperatorOrHigher(kind) {
    return isShiftOperatorOrHigher(kind)
        || isRelationalOperator(kind);
}
export function isEqualityOperator(kind) {
    return kind === SyntaxKind.EqualsEqualsToken
        || kind === SyntaxKind.EqualsEqualsEqualsToken
        || kind === SyntaxKind.ExclamationEqualsEqualsToken
        || kind === SyntaxKind.ExclamationEqualsToken;
}
export function isEqualityOperatorOrHigher(kind) {
    return isRelationalOperatorOrHigher(kind)
        || isEqualityOperator(kind);
}
export function isBitwiseOperator(kind) {
    return kind === SyntaxKind.AmpersandToken
        || kind === SyntaxKind.BarToken
        || kind === SyntaxKind.CaretToken;
}
export function isBitwiseOperatorOrHigher(kind) {
    return isEqualityOperatorOrHigher(kind)
        || isBitwiseOperator(kind);
}
export function isLogicalOperator(kind) {
    return kind === SyntaxKind.AmpersandAmpersandToken
        || kind === SyntaxKind.BarBarToken;
}
export function isLogicalOperatorOrHigher(kind) {
    return isBitwiseOperatorOrHigher(kind)
        || isLogicalOperator(kind);
}
export function isCompoundAssignmentOperator(kind) {
    return kind === SyntaxKind.PlusEqualsToken
        || kind === SyntaxKind.MinusEqualsToken
        || kind === SyntaxKind.AsteriskAsteriskEqualsToken
        || kind === SyntaxKind.AsteriskEqualsToken
        || kind === SyntaxKind.SlashEqualsToken
        || kind === SyntaxKind.PercentEqualsToken
        || kind === SyntaxKind.AmpersandEqualsToken
        || kind === SyntaxKind.BarEqualsToken
        || kind === SyntaxKind.CaretEqualsToken
        || kind === SyntaxKind.LessThanLessThanEqualsToken
        || kind === SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken
        || kind === SyntaxKind.GreaterThanGreaterThanEqualsToken
        || kind === SyntaxKind.BarBarEqualsToken
        || kind === SyntaxKind.AmpersandAmpersandEqualsToken
        || kind === SyntaxKind.QuestionQuestionEqualsToken;
}
export function isAssignmentOperatorOrHigher(kind) {
    return kind === SyntaxKind.QuestionQuestionToken
        || isLogicalOperatorOrHigher(kind)
        || isAssignmentOperator(kind);
}
export function isLogicalOrCoalescingAssignmentOperator(kind) {
    return kind === SyntaxKind.AmpersandAmpersandEqualsToken
        || kind === SyntaxKind.BarBarEqualsToken
        || kind === SyntaxKind.QuestionQuestionEqualsToken;
}
export function isLiteralKind(kind) {
    return kind >= SyntaxKind.FirstLiteralToken && kind <= SyntaxKind.LastLiteralToken;
}
export function isPunctuationKind(kind) {
    return kind >= SyntaxKind.FirstPunctuation && kind <= SyntaxKind.LastPunctuation;
}
export function isKeywordKind(kind) {
    return kind >= SyntaxKind.FirstKeyword && kind <= SyntaxKind.LastKeyword;
}
export function isTokenKind(kind) {
    return kind >= SyntaxKind.FirstToken && kind <= SyntaxKind.LastToken;
}
export function isJSDocNodeKind(kind) {
    return kind >= SyntaxKind.FirstJSDocNode && kind <= SyntaxKind.LastJSDocNode;
}
export function isEndOfFile(node) {
    return node.kind === SyntaxKind.EndOfFile;
}
isEndOfFile.Handle = isEndOfFile;
export function isDotToken(node) {
    return node.kind === SyntaxKind.DotToken;
}
isDotToken.Handle = isDotToken;
export function isDotDotDotToken(node) {
    return node.kind === SyntaxKind.DotDotDotToken;
}
isDotDotDotToken.Handle = isDotDotDotToken;
export function isQuestionToken(node) {
    return node.kind === SyntaxKind.QuestionToken;
}
isQuestionToken.Handle = isQuestionToken;
export function isExclamationToken(node) {
    return node.kind === SyntaxKind.ExclamationToken;
}
isExclamationToken.Handle = isExclamationToken;
export function isColonToken(node) {
    return node.kind === SyntaxKind.ColonToken;
}
isColonToken.Handle = isColonToken;
export function isEqualsToken(node) {
    return node.kind === SyntaxKind.EqualsToken;
}
isEqualsToken.Handle = isEqualsToken;
export function isAsteriskToken(node) {
    return node.kind === SyntaxKind.AsteriskToken;
}
isAsteriskToken.Handle = isAsteriskToken;
export function isEqualsGreaterThanToken(node) {
    return node.kind === SyntaxKind.EqualsGreaterThanToken;
}
isEqualsGreaterThanToken.Handle = isEqualsGreaterThanToken;
export function isPlusToken(node) {
    return node.kind === SyntaxKind.PlusToken;
}
isPlusToken.Handle = isPlusToken;
export function isMinusToken(node) {
    return node.kind === SyntaxKind.MinusToken;
}
isMinusToken.Handle = isMinusToken;
export function isQuestionDotToken(node) {
    return node.kind === SyntaxKind.QuestionDotToken;
}
isQuestionDotToken.Handle = isQuestionDotToken;
export function isAssertsKeyword(node) {
    return node.kind === SyntaxKind.AssertsKeyword;
}
isAssertsKeyword.Handle = isAssertsKeyword;
export function isAssertKeyword(node) {
    return node.kind === SyntaxKind.AssertKeyword;
}
isAssertKeyword.Handle = isAssertKeyword;
export function isAwaitKeyword(node) {
    return node.kind === SyntaxKind.AwaitKeyword;
}
isAwaitKeyword.Handle = isAwaitKeyword;
export function isCaseKeyword(node) {
    return node.kind === SyntaxKind.CaseKeyword;
}
isCaseKeyword.Handle = isCaseKeyword;
export function isAbstractKeyword(node) {
    return node.kind === SyntaxKind.AbstractKeyword;
}
isAbstractKeyword.Handle = isAbstractKeyword;
export function isAccessorKeyword(node) {
    return node.kind === SyntaxKind.AccessorKeyword;
}
isAccessorKeyword.Handle = isAccessorKeyword;
export function isAsyncKeyword(node) {
    return node.kind === SyntaxKind.AsyncKeyword;
}
isAsyncKeyword.Handle = isAsyncKeyword;
export function isConstKeyword(node) {
    return node.kind === SyntaxKind.ConstKeyword;
}
isConstKeyword.Handle = isConstKeyword;
export function isDeclareKeyword(node) {
    return node.kind === SyntaxKind.DeclareKeyword;
}
isDeclareKeyword.Handle = isDeclareKeyword;
export function isDefaultKeyword(node) {
    return node.kind === SyntaxKind.DefaultKeyword;
}
isDefaultKeyword.Handle = isDefaultKeyword;
export function isExportKeyword(node) {
    return node.kind === SyntaxKind.ExportKeyword;
}
isExportKeyword.Handle = isExportKeyword;
export function isInKeyword(node) {
    return node.kind === SyntaxKind.InKeyword;
}
isInKeyword.Handle = isInKeyword;
export function isPrivateKeyword(node) {
    return node.kind === SyntaxKind.PrivateKeyword;
}
isPrivateKeyword.Handle = isPrivateKeyword;
export function isProtectedKeyword(node) {
    return node.kind === SyntaxKind.ProtectedKeyword;
}
isProtectedKeyword.Handle = isProtectedKeyword;
export function isPublicKeyword(node) {
    return node.kind === SyntaxKind.PublicKeyword;
}
isPublicKeyword.Handle = isPublicKeyword;
export function isReadonlyKeyword(node) {
    return node.kind === SyntaxKind.ReadonlyKeyword;
}
isReadonlyKeyword.Handle = isReadonlyKeyword;
export function isOutKeyword(node) {
    return node.kind === SyntaxKind.OutKeyword;
}
isOutKeyword.Handle = isOutKeyword;
export function isOverrideKeyword(node) {
    return node.kind === SyntaxKind.OverrideKeyword;
}
isOverrideKeyword.Handle = isOverrideKeyword;
export function isStaticKeyword(node) {
    return node.kind === SyntaxKind.StaticKeyword;
}
isStaticKeyword.Handle = isStaticKeyword;
export function isBinaryOperatorToken(node) {
    return isBinaryOperator(node.kind);
}
isBinaryOperatorToken.Handle = isBinaryOperatorToken;
export function isAssignmentOperatorToken(node) {
    return isAssignmentOperator(node.kind);
}
isAssignmentOperatorToken.Handle = isAssignmentOperatorToken;
export function isNullLiteral(node) {
    return node.kind === SyntaxKind.NullKeyword;
}
isNullLiteral.Handle = isNullLiteral;
export function isTrueLiteral(node) {
    return node.kind === SyntaxKind.TrueKeyword;
}
isTrueLiteral.Handle = isTrueLiteral;
export function isFalseLiteral(node) {
    return node.kind === SyntaxKind.FalseKeyword;
}
isFalseLiteral.Handle = isFalseLiteral;
export function isThisExpression(node) {
    return node.kind === SyntaxKind.ThisKeyword;
}
isThisExpression.Handle = isThisExpression;
export function isSuperExpression(node) {
    return node.kind === SyntaxKind.SuperKeyword;
}
isSuperExpression.Handle = isSuperExpression;
export function isImportExpression(node) {
    return node.kind === SyntaxKind.ImportKeyword;
}
isImportExpression.Handle = isImportExpression;
//# sourceMappingURL=is.generated.js.map