@scriptc/compiler 0.1.6 → 0.2.0

package/dist/frontend/ts7/ast-guards.generated.js

@@ -0,0 +1,1951 @@
+// Generated from typescript@7.0.2 by scripts/generate-ts7-ast-schema.mjs.
+// TypeScript is Copyright Microsoft Corporation, licensed under Apache-2.0.
+// Regenerate when changing the TypeScript pin; do not edit by hand.
+import { SyntaxKind, NodeFlags, ScriptKind, OuterExpressionKinds } from "./enums.js";
+export function isToken(node) {
+    if (node === undefined)
+        return false;
+    return isTokenKind(node.kind);
+}
+export function isIdentifier(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.Identifier;
+}
+export function isPrivateIdentifier(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.PrivateIdentifier;
+}
+export function isQualifiedName(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.QualifiedName;
+}
+export function isComputedPropertyName(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ComputedPropertyName;
+}
+export function isDecorator(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.Decorator;
+}
+export function isEmptyStatement(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.EmptyStatement;
+}
+export function isIfStatement(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.IfStatement;
+}
+export function isDoStatement(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.DoStatement;
+}
+export function isWhileStatement(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.WhileStatement;
+}
+export function isForStatement(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ForStatement;
+}
+export function isBreakStatement(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.BreakStatement;
+}
+export function isContinueStatement(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ContinueStatement;
+}
+export function isReturnStatement(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ReturnStatement;
+}
+export function isWithStatement(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.WithStatement;
+}
+export function isSwitchStatement(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.SwitchStatement;
+}
+export function isCaseBlock(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.CaseBlock;
+}
+export function isThrowStatement(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ThrowStatement;
+}
+export function isTryStatement(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.TryStatement;
+}
+export function isCatchClause(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.CatchClause;
+}
+export function isDebuggerStatement(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.DebuggerStatement;
+}
+export function isLabeledStatement(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.LabeledStatement;
+}
+export function isExpressionStatement(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ExpressionStatement;
+}
+export function isBlock(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.Block;
+}
+export function isVariableStatement(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.VariableStatement;
+}
+export function isVariableDeclaration(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.VariableDeclaration;
+}
+export function isVariableDeclarationList(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.VariableDeclarationList;
+}
+export function isParameterDeclaration(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.Parameter;
+}
+export function isBindingElement(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.BindingElement;
+}
+export function isMissingDeclaration(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.MissingDeclaration;
+}
+export function isFunctionDeclaration(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.FunctionDeclaration;
+}
+export function isClassDeclaration(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ClassDeclaration;
+}
+export function isClassExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ClassExpression;
+}
+export function isHeritageClause(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.HeritageClause;
+}
+export function isInterfaceDeclaration(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.InterfaceDeclaration;
+}
+export function isTypeAliasDeclaration(node) {
+    if (node === undefined)
+        return false;
+    switch (node.kind) {
+        case SyntaxKind.TypeAliasDeclaration:
+        case SyntaxKind.JSTypeAliasDeclaration:
+            return true;
+        default:
+            return false;
+    }
+}
+export function isEnumMember(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.EnumMember;
+}
+export function isEnumDeclaration(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.EnumDeclaration;
+}
+export function isModuleBlock(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ModuleBlock;
+}
+export function isNotEmittedStatement(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.NotEmittedStatement;
+}
+export function isNotEmittedTypeElement(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.NotEmittedTypeElement;
+}
+export function isImportDeclaration(node) {
+    if (node === undefined)
+        return false;
+    switch (node.kind) {
+        case SyntaxKind.ImportDeclaration:
+        case SyntaxKind.JSImportDeclaration:
+            return true;
+        default:
+            return false;
+    }
+}
+export function isExternalModuleReference(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ExternalModuleReference;
+}
+export function isNamespaceImport(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.NamespaceImport;
+}
+export function isNamedImports(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.NamedImports;
+}
+export function isExportAssignment(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ExportAssignment;
+}
+export function isNamespaceExportDeclaration(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.NamespaceExportDeclaration;
+}
+export function isNamespaceExport(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.NamespaceExport;
+}
+export function isNamedExports(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.NamedExports;
+}
+export function isExportSpecifier(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ExportSpecifier;
+}
+export function isCallSignatureDeclaration(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.CallSignature;
+}
+export function isConstructSignatureDeclaration(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ConstructSignature;
+}
+export function isConstructorDeclaration(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.Constructor;
+}
+export function isGetAccessorDeclaration(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.GetAccessor;
+}
+export function isSetAccessorDeclaration(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.SetAccessor;
+}
+export function isIndexSignatureDeclaration(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.IndexSignature;
+}
+export function isMethodSignatureDeclaration(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.MethodSignature;
+}
+export function isMethodDeclaration(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.MethodDeclaration;
+}
+export function isPropertySignatureDeclaration(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.PropertySignature;
+}
+export function isPropertyDeclaration(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.PropertyDeclaration;
+}
+export function isSemicolonClassElement(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.SemicolonClassElement;
+}
+export function isClassStaticBlockDeclaration(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ClassStaticBlockDeclaration;
+}
+export function isOmittedExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.OmittedExpression;
+}
+export function isKeywordExpression(node) {
+    if (node === undefined)
+        return false;
+    return isKeywordExpressionKind(node.kind);
+}
+export function isStringLiteral(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.StringLiteral;
+}
+export function isNumericLiteral(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.NumericLiteral;
+}
+export function isBigIntLiteral(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.BigIntLiteral;
+}
+export function isRegularExpressionLiteral(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.RegularExpressionLiteral;
+}
+export function isNoSubstitutionTemplateLiteral(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.NoSubstitutionTemplateLiteral;
+}
+export function isBinaryExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.BinaryExpression;
+}
+export function isPrefixUnaryExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.PrefixUnaryExpression;
+}
+export function isPostfixUnaryExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.PostfixUnaryExpression;
+}
+export function isYieldExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.YieldExpression;
+}
+export function isArrowFunction(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ArrowFunction;
+}
+export function isFunctionExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.FunctionExpression;
+}
+export function isAsExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.AsExpression;
+}
+export function isSatisfiesExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.SatisfiesExpression;
+}
+export function isConditionalExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ConditionalExpression;
+}
+export function isPropertyAccessExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.PropertyAccessExpression;
+}
+export function isElementAccessExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ElementAccessExpression;
+}
+export function isCallExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.CallExpression;
+}
+export function isNewExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.NewExpression;
+}
+export function isMetaProperty(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.MetaProperty;
+}
+export function isNonNullExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.NonNullExpression;
+}
+export function isSpreadElement(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.SpreadElement;
+}
+export function isTemplateExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.TemplateExpression;
+}
+export function isTemplateSpan(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.TemplateSpan;
+}
+export function isTaggedTemplateExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.TaggedTemplateExpression;
+}
+export function isParenthesizedExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ParenthesizedExpression;
+}
+export function isArrayLiteralExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ArrayLiteralExpression;
+}
+export function isObjectLiteralExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ObjectLiteralExpression;
+}
+export function isSpreadAssignment(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.SpreadAssignment;
+}
+export function isPropertyAssignment(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.PropertyAssignment;
+}
+export function isShorthandPropertyAssignment(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ShorthandPropertyAssignment;
+}
+export function isDeleteExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.DeleteExpression;
+}
+export function isTypeOfExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.TypeOfExpression;
+}
+export function isVoidExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.VoidExpression;
+}
+export function isAwaitExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.AwaitExpression;
+}
+export function isTypeAssertion(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.TypeAssertionExpression;
+}
+export function isKeywordTypeNode(node) {
+    if (node === undefined)
+        return false;
+    return isKeywordTypeKind(node.kind);
+}
+export function isUnionTypeNode(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.UnionType;
+}
+export function isIntersectionTypeNode(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.IntersectionType;
+}
+export function isConditionalTypeNode(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ConditionalType;
+}
+export function isTypeOperatorNode(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.TypeOperator;
+}
+export function isInferTypeNode(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.InferType;
+}
+export function isArrayTypeNode(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ArrayType;
+}
+export function isIndexedAccessTypeNode(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.IndexedAccessType;
+}
+export function isTypeReferenceNode(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.TypeReference;
+}
+export function isExpressionWithTypeArguments(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ExpressionWithTypeArguments;
+}
+export function isLiteralTypeNode(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.LiteralType;
+}
+export function isThisTypeNode(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ThisType;
+}
+export function isTypePredicateNode(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.TypePredicate;
+}
+export function isImportAttribute(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ImportAttribute;
+}
+export function isImportAttributes(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ImportAttributes;
+}
+export function isTypeQueryNode(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.TypeQuery;
+}
+export function isMappedTypeNode(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.MappedType;
+}
+export function isTypeLiteralNode(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.TypeLiteral;
+}
+export function isTupleTypeNode(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.TupleType;
+}
+export function isNamedTupleMember(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.NamedTupleMember;
+}
+export function isOptionalTypeNode(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.OptionalType;
+}
+export function isRestTypeNode(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.RestType;
+}
+export function isParenthesizedTypeNode(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ParenthesizedType;
+}
+export function isFunctionTypeNode(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.FunctionType;
+}
+export function isConstructorTypeNode(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ConstructorType;
+}
+export function isTemplateHead(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.TemplateHead;
+}
+export function isTemplateMiddle(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.TemplateMiddle;
+}
+export function isTemplateTail(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.TemplateTail;
+}
+export function isTemplateLiteralTypeNode(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.TemplateLiteralType;
+}
+export function isTemplateLiteralTypeSpan(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.TemplateLiteralTypeSpan;
+}
+export function isSyntheticExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.SyntheticExpression;
+}
+export function isPartiallyEmittedExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.PartiallyEmittedExpression;
+}
+export function isJsxElement(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JsxElement;
+}
+export function isJsxAttributes(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JsxAttributes;
+}
+export function isJsxNamespacedName(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JsxNamespacedName;
+}
+export function isJsxOpeningElement(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JsxOpeningElement;
+}
+export function isJsxSelfClosingElement(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JsxSelfClosingElement;
+}
+export function isJsxFragment(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JsxFragment;
+}
+export function isJsxOpeningFragment(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JsxOpeningFragment;
+}
+export function isJsxClosingFragment(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JsxClosingFragment;
+}
+export function isJsxAttribute(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JsxAttribute;
+}
+export function isJsxSpreadAttribute(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JsxSpreadAttribute;
+}
+export function isJsxClosingElement(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JsxClosingElement;
+}
+export function isJsxExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JsxExpression;
+}
+export function isJsxText(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JsxText;
+}
+export function isSyntaxList(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.SyntaxList;
+}
+export function isJSDoc(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDoc;
+}
+export function isJSDocTypeExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocTypeExpression;
+}
+export function isJSDocNonNullableType(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocNonNullableType;
+}
+export function isJSDocNullableType(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocNullableType;
+}
+export function isJSDocAllType(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocAllType;
+}
+export function isJSDocVariadicType(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocVariadicType;
+}
+export function isJSDocOptionalType(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocOptionalType;
+}
+export function isJSDocTypeTag(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocTypeTag;
+}
+export function isJSDocUnknownTag(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocUnknownTag;
+}
+export function isJSDocTemplateTag(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocTemplateTag;
+}
+export function isJSDocReturnTag(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocReturnTag;
+}
+export function isJSDocPublicTag(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocPublicTag;
+}
+export function isJSDocPrivateTag(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocPrivateTag;
+}
+export function isJSDocProtectedTag(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocProtectedTag;
+}
+export function isJSDocReadonlyTag(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocReadonlyTag;
+}
+export function isJSDocOverrideTag(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocOverrideTag;
+}
+export function isJSDocDeprecatedTag(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocDeprecatedTag;
+}
+export function isJSDocSeeTag(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocSeeTag;
+}
+export function isJSDocImplementsTag(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocImplementsTag;
+}
+export function isJSDocAugmentsTag(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocAugmentsTag;
+}
+export function isJSDocSatisfiesTag(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocSatisfiesTag;
+}
+export function isJSDocThrowsTag(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocThrowsTag;
+}
+export function isJSDocThisTag(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocThisTag;
+}
+export function isJSDocImportTag(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocImportTag;
+}
+export function isJSDocCallbackTag(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocCallbackTag;
+}
+export function isJSDocOverloadTag(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocOverloadTag;
+}
+export function isJSDocTypedefTag(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocTypedefTag;
+}
+export function isJSDocSignature(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocSignature;
+}
+export function isJSDocNameReference(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocNameReference;
+}
+export function isSourceFile(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.SourceFile;
+}
+export function isModuleDeclaration(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ModuleDeclaration;
+}
+export function isImportEqualsDeclaration(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ImportEqualsDeclaration;
+}
+export function isExportDeclaration(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ExportDeclaration;
+}
+export function isImportTypeNode(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ImportType;
+}
+export function isImportClause(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ImportClause;
+}
+export function isImportSpecifier(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ImportSpecifier;
+}
+export function isJSDocText(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocText;
+}
+export function isJSDocLink(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocLink;
+}
+export function isJSDocLinkPlain(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocLinkPlain;
+}
+export function isJSDocLinkCode(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocLinkCode;
+}
+export function isTypeParameterDeclaration(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.TypeParameter;
+}
+export function isSyntheticReferenceExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.SyntheticReferenceExpression;
+}
+export function isJSDocTypeLiteral(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocTypeLiteral;
+}
+export function isForInStatement(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ForInStatement;
+}
+export function isForOfStatement(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ForOfStatement;
+}
+export function isCaseClause(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.CaseClause;
+}
+export function isDefaultClause(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.DefaultClause;
+}
+export function isObjectBindingPattern(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ObjectBindingPattern;
+}
+export function isArrayBindingPattern(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ArrayBindingPattern;
+}
+export function isJSDocParameterTag(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocParameterTag;
+}
+export function isJSDocPropertyTag(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocPropertyTag;
+}
+export function isAccessExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.PropertyAccessExpression || node.kind === SyntaxKind.ElementAccessExpression;
+}
+export function isDeclarationName(node) {
+    if (node === undefined)
+        return false;
+    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.ElementAccessExpression;
+}
+export function isModuleName(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.StringLiteral;
+}
+export function isModuleExportName(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.StringLiteral;
+}
+export function isPropertyName(node) {
+    if (node === undefined)
+        return false;
+    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;
+}
+export function isModuleBody(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ModuleBlock || node.kind === SyntaxKind.ModuleDeclaration;
+}
+export function isJSDocFullName(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.ModuleDeclaration;
+}
+export function isModuleReference(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName || node.kind === SyntaxKind.ExternalModuleReference;
+}
+export function isNamedImportBindings(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.NamespaceImport || node.kind === SyntaxKind.NamedImports;
+}
+export function isNamedExportBindings(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.NamespaceExport || node.kind === SyntaxKind.NamedExports;
+}
+export function isMemberName(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.PrivateIdentifier;
+}
+export function isEntityName(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName;
+}
+export function isBindingName(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.ObjectBindingPattern || node.kind === SyntaxKind.ArrayBindingPattern;
+}
+export function isModifierLike(node) {
+    if (node === undefined)
+        return false;
+    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;
+}
+export function isJsxChild(node) {
+    if (node === undefined)
+        return false;
+    const kind = node.kind;
+    return kind === SyntaxKind.JsxText || kind === SyntaxKind.JsxExpression || kind === SyntaxKind.JsxElement || kind === SyntaxKind.JsxSelfClosingElement || kind === SyntaxKind.JsxFragment;
+}
+export function isJsxAttributeLike(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JsxAttribute || node.kind === SyntaxKind.JsxSpreadAttribute;
+}
+export function isJsxAttributeName(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.JsxNamespacedName;
+}
+export function isJsxAttributeValue(node) {
+    if (node === undefined)
+        return false;
+    const kind = node.kind;
+    return kind === SyntaxKind.StringLiteral || kind === SyntaxKind.JsxExpression || kind === SyntaxKind.JsxElement || kind === SyntaxKind.JsxSelfClosingElement || kind === SyntaxKind.JsxFragment;
+}
+export function isClassLikeDeclaration(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ClassDeclaration || node.kind === SyntaxKind.ClassExpression;
+}
+export function isAccessorDeclaration(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.GetAccessor || node.kind === SyntaxKind.SetAccessor;
+}
+export function isLiteralLikeNode(node) {
+    if (node === undefined)
+        return false;
+    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;
+}
+export function isLiteralExpression(node) {
+    if (node === undefined)
+        return false;
+    const kind = node.kind;
+    return kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.BigIntLiteral || kind === SyntaxKind.RegularExpressionLiteral || kind === SyntaxKind.NoSubstitutionTemplateLiteral;
+}
+export function isUnionOrIntersectionTypeNode(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.UnionType || node.kind === SyntaxKind.IntersectionType;
+}
+export function isTemplateLiteralLikeNode(node) {
+    if (node === undefined)
+        return false;
+    const kind = node.kind;
+    return isPseudoLiteralKind(kind);
+}
+export function isTemplateMiddleOrTail(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.TemplateMiddle || node.kind === SyntaxKind.TemplateTail;
+}
+export function isTemplateLiteral(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.TemplateExpression || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral;
+}
+export function isTypePredicateParameterName(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.ThisType;
+}
+export function isImportAttributeName(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.StringLiteral;
+}
+export function isJSDocComment(node) {
+    if (node === undefined)
+        return false;
+    const kind = node.kind;
+    return kind === SyntaxKind.JSDocText || kind === SyntaxKind.JSDocLink || kind === SyntaxKind.JSDocLinkCode || kind === SyntaxKind.JSDocLinkPlain;
+}
+export function isSignatureDeclaration(node) {
+    if (node === undefined)
+        return false;
+    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;
+}
+export function isStringLiteralLikeNode(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral;
+}
+export function isNumericOrStringLikeLiteral(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral || node.kind === SyntaxKind.NumericLiteral;
+}
+export function isObjectLiteralLikeNode(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ObjectLiteralExpression || node.kind === SyntaxKind.ObjectBindingPattern;
+}
+export function isObjectTypeDeclaration(node) {
+    if (node === undefined)
+        return false;
+    const kind = node.kind;
+    return kind === SyntaxKind.ClassDeclaration || kind === SyntaxKind.ClassExpression || kind === SyntaxKind.InterfaceDeclaration || kind === SyntaxKind.TypeLiteral;
+}
+export function isJsxOpeningLikeElement(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JsxOpeningElement || node.kind === SyntaxKind.JsxSelfClosingElement;
+}
+export function isNamedImportsOrExports(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.NamedImports || node.kind === SyntaxKind.NamedExports;
+}
+export function isBreakOrContinueStatement(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.BreakStatement || node.kind === SyntaxKind.ContinueStatement;
+}
+export function isCallLikeExpression(node) {
+    if (node === undefined)
+        return false;
+    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;
+}
+export function isFunctionLikeDeclaration(node) {
+    if (node === undefined)
+        return false;
+    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;
+}
+export function isVariableOrParameterDeclaration(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.VariableDeclaration || node.kind === SyntaxKind.Parameter;
+}
+export function isVariableOrPropertyDeclaration(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.VariableDeclaration || node.kind === SyntaxKind.PropertyDeclaration;
+}
+export function isCallOrNewExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.CallExpression || node.kind === SyntaxKind.NewExpression;
+}
+export function isImportClauseOrBindingPattern(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ImportClause || node.kind === SyntaxKind.ObjectBindingPattern || node.kind === SyntaxKind.ArrayBindingPattern;
+}
+export function isAnyImportSyntax(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ImportDeclaration || node.kind === SyntaxKind.JSImportDeclaration || node.kind === SyntaxKind.ImportEqualsDeclaration;
+}
+export function isArrayBindingElement(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.BindingElement || node.kind === SyntaxKind.OmittedExpression;
+}
+export function isAssertionExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.TypeAssertionExpression || node.kind === SyntaxKind.AsExpression;
+}
+export function isBooleanLiteral(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.TrueKeyword || node.kind === SyntaxKind.FalseKeyword;
+}
+export function isDestructuringAssignment(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.BinaryExpression;
+}
+export function isLiteralToken(node) {
+    if (node === undefined)
+        return false;
+    const kind = node.kind;
+    return kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.BigIntLiteral || kind === SyntaxKind.StringLiteral || kind === SyntaxKind.JsxText || kind === SyntaxKind.RegularExpressionLiteral || kind === SyntaxKind.NoSubstitutionTemplateLiteral;
+}
+export function isModifier(node) {
+    if (node === undefined)
+        return false;
+    const kind = node.kind;
+    return isModifierKind(kind);
+}
+export function isObjectLiteralElementLike(node) {
+    if (node === undefined)
+        return false;
+    const kind = node.kind;
+    return kind === SyntaxKind.PropertyAssignment || kind === SyntaxKind.ShorthandPropertyAssignment || kind === SyntaxKind.SpreadAssignment || kind === SyntaxKind.MethodDeclaration || kind === SyntaxKind.GetAccessor || kind === SyntaxKind.SetAccessor;
+}
+export function isPropertyNameLiteral(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NumericLiteral;
+}
+export function isPseudoLiteralToken(node) {
+    if (node === undefined)
+        return false;
+    const kind = node.kind;
+    return isPseudoLiteralKind(kind);
+}
+export function isTemplateLiteralToken(node) {
+    if (node === undefined)
+        return false;
+    const kind = node.kind;
+    return kind === SyntaxKind.NoSubstitutionTemplateLiteral || kind === SyntaxKind.TemplateHead || kind === SyntaxKind.TemplateMiddle || kind === SyntaxKind.TemplateTail;
+}
+export function isArrayDestructuringAssignment(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.BinaryExpression;
+}
+export function isObjectDestructuringAssignment(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.BinaryExpression;
+}
+export function isFunctionBody(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.Block;
+}
+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;
+}
+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) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.EndOfFile;
+}
+export function isDotToken(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.DotToken;
+}
+export function isDotDotDotToken(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.DotDotDotToken;
+}
+export function isQuestionToken(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.QuestionToken;
+}
+export function isExclamationToken(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ExclamationToken;
+}
+export function isColonToken(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ColonToken;
+}
+export function isEqualsToken(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.EqualsToken;
+}
+export function isAsteriskToken(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.AsteriskToken;
+}
+export function isEqualsGreaterThanToken(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.EqualsGreaterThanToken;
+}
+export function isPlusToken(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.PlusToken;
+}
+export function isMinusToken(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.MinusToken;
+}
+export function isQuestionDotToken(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.QuestionDotToken;
+}
+export function isAssertsKeyword(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.AssertsKeyword;
+}
+export function isAssertKeyword(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.AssertKeyword;
+}
+export function isAwaitKeyword(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.AwaitKeyword;
+}
+export function isCaseKeyword(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.CaseKeyword;
+}
+export function isAbstractKeyword(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.AbstractKeyword;
+}
+export function isAccessorKeyword(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.AccessorKeyword;
+}
+export function isAsyncKeyword(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.AsyncKeyword;
+}
+export function isConstKeyword(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ConstKeyword;
+}
+export function isDeclareKeyword(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.DeclareKeyword;
+}
+export function isDefaultKeyword(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.DefaultKeyword;
+}
+export function isExportKeyword(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ExportKeyword;
+}
+export function isInKeyword(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.InKeyword;
+}
+export function isPrivateKeyword(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.PrivateKeyword;
+}
+export function isProtectedKeyword(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ProtectedKeyword;
+}
+export function isPublicKeyword(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.PublicKeyword;
+}
+export function isReadonlyKeyword(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ReadonlyKeyword;
+}
+export function isOutKeyword(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.OutKeyword;
+}
+export function isOverrideKeyword(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.OverrideKeyword;
+}
+export function isStaticKeyword(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.StaticKeyword;
+}
+export function isBinaryOperatorToken(node) {
+    if (node === undefined)
+        return false;
+    return isBinaryOperator(node.kind);
+}
+export function isAssignmentOperatorToken(node) {
+    if (node === undefined)
+        return false;
+    return isAssignmentOperator(node.kind);
+}
+export function isNullLiteral(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.NullKeyword;
+}
+export function isTrueLiteral(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.TrueKeyword;
+}
+export function isFalseLiteral(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.FalseKeyword;
+}
+export function isThisExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ThisKeyword;
+}
+export function isSuperExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.SuperKeyword;
+}
+export function isImportExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ImportKeyword;
+}
+export function isTypeNode(node) {
+    if (node === undefined)
+        return false;
+    return isTypeNodeKind(node.kind);
+}
+function isTypeNodeKind(kind) {
+    return kind >= SyntaxKind.FirstTypeNode && kind <= SyntaxKind.LastTypeNode
+        || kind === SyntaxKind.AnyKeyword
+        || kind === SyntaxKind.UnknownKeyword
+        || kind === SyntaxKind.NumberKeyword
+        || kind === SyntaxKind.BigIntKeyword
+        || kind === SyntaxKind.ObjectKeyword
+        || kind === SyntaxKind.BooleanKeyword
+        || kind === SyntaxKind.StringKeyword
+        || kind === SyntaxKind.SymbolKeyword
+        || kind === SyntaxKind.VoidKeyword
+        || kind === SyntaxKind.UndefinedKeyword
+        || kind === SyntaxKind.NeverKeyword
+        || kind === SyntaxKind.IntrinsicKeyword
+        || kind === SyntaxKind.ExpressionWithTypeArguments
+        || kind === SyntaxKind.JSDocAllType
+        || kind === SyntaxKind.JSDocNullableType
+        || kind === SyntaxKind.JSDocNonNullableType
+        || kind === SyntaxKind.JSDocOptionalType
+        || kind === SyntaxKind.JSDocVariadicType
+        || kind === SyntaxKind.JSDocTypeExpression
+        || kind === SyntaxKind.JSDocTypeLiteral
+        || kind === SyntaxKind.JSDocSignature;
+}
+export function isStatement(node) {
+    if (node === undefined)
+        return false;
+    const kind = node.kind;
+    return kind === SyntaxKind.VariableStatement || kind === SyntaxKind.EmptyStatement
+        || kind === SyntaxKind.ExpressionStatement || kind === SyntaxKind.IfStatement
+        || kind === SyntaxKind.DoStatement || kind === SyntaxKind.WhileStatement
+        || kind === SyntaxKind.ForStatement || kind === SyntaxKind.ForInStatement
+        || kind === SyntaxKind.ForOfStatement || kind === SyntaxKind.ContinueStatement
+        || kind === SyntaxKind.BreakStatement || kind === SyntaxKind.ReturnStatement
+        || kind === SyntaxKind.WithStatement || kind === SyntaxKind.SwitchStatement
+        || kind === SyntaxKind.LabeledStatement || kind === SyntaxKind.ThrowStatement
+        || kind === SyntaxKind.TryStatement || kind === SyntaxKind.DebuggerStatement
+        || kind === SyntaxKind.InterfaceDeclaration || kind === SyntaxKind.TypeAliasDeclaration
+        || kind === SyntaxKind.EnumDeclaration || kind === SyntaxKind.ModuleDeclaration
+        || kind === SyntaxKind.ImportDeclaration || kind === SyntaxKind.ImportEqualsDeclaration
+        || kind === SyntaxKind.ExportDeclaration || kind === SyntaxKind.ExportAssignment
+        || kind === SyntaxKind.NamespaceExportDeclaration || kind === SyntaxKind.FunctionDeclaration
+        || kind === SyntaxKind.ClassDeclaration || kind === SyntaxKind.MissingDeclaration
+        || kind === SyntaxKind.NotEmittedStatement || kind === SyntaxKind.Block;
+}
+export function isExpression(node) {
+    if (node === undefined)
+        return false;
+    const kind = node.kind;
+    return kind === SyntaxKind.ConditionalExpression || kind === SyntaxKind.YieldExpression
+        || kind === SyntaxKind.ArrowFunction || kind === SyntaxKind.BinaryExpression
+        || kind === SyntaxKind.SpreadElement || kind === SyntaxKind.AsExpression
+        || kind === SyntaxKind.OmittedExpression
+        || kind === SyntaxKind.SatisfiesExpression
+        || kind === SyntaxKind.PrefixUnaryExpression || kind === SyntaxKind.PostfixUnaryExpression
+        || kind === SyntaxKind.DeleteExpression || kind === SyntaxKind.TypeOfExpression
+        || kind === SyntaxKind.VoidExpression || kind === SyntaxKind.AwaitExpression
+        || kind === SyntaxKind.TypeAssertionExpression
+        || kind === SyntaxKind.CallExpression || kind === SyntaxKind.NewExpression
+        || kind === SyntaxKind.TaggedTemplateExpression || kind === SyntaxKind.NonNullExpression
+        || kind === SyntaxKind.MetaProperty || kind === SyntaxKind.JsxExpression
+        || kind === SyntaxKind.PropertyAccessExpression || kind === SyntaxKind.ElementAccessExpression
+        || kind === SyntaxKind.FunctionExpression || kind === SyntaxKind.ClassExpression
+        || kind === SyntaxKind.ParenthesizedExpression || kind === SyntaxKind.ArrayLiteralExpression
+        || kind === SyntaxKind.ObjectLiteralExpression || kind === SyntaxKind.TemplateExpression
+        || kind === SyntaxKind.Identifier
+        || kind === SyntaxKind.PrivateIdentifier
+        || kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.BigIntLiteral
+        || kind === SyntaxKind.StringLiteral || kind === SyntaxKind.RegularExpressionLiteral
+        || kind === SyntaxKind.NoSubstitutionTemplateLiteral || kind === SyntaxKind.JsxElement
+        || kind === SyntaxKind.JsxSelfClosingElement || kind === SyntaxKind.JsxFragment
+        || kind === SyntaxKind.NullKeyword || kind === SyntaxKind.TrueKeyword
+        || kind === SyntaxKind.FalseKeyword || kind === SyntaxKind.ThisKeyword
+        || kind === SyntaxKind.SuperKeyword || kind === SyntaxKind.ImportKeyword
+        || kind === SyntaxKind.ExpressionWithTypeArguments;
+}
+export function isBlockOrExpression(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.Block || isExpression(node);
+}
+export function isLeftHandSideExpression(node) {
+    if (node === undefined)
+        return false;
+    return isLeftHandSideExpressionKind(skipPartiallyEmittedExpressions(node).kind);
+}
+export function skipPartiallyEmittedExpressions(node) {
+    return skipOuterExpressions(node, OuterExpressionKinds.PartiallyEmittedExpressions);
+}
+function isLeftHandSideExpressionKind(kind) {
+    switch (kind) {
+        case SyntaxKind.PropertyAccessExpression:
+        case SyntaxKind.ElementAccessExpression:
+        case SyntaxKind.NewExpression:
+        case SyntaxKind.CallExpression:
+        case SyntaxKind.JsxElement:
+        case SyntaxKind.JsxSelfClosingElement:
+        case SyntaxKind.JsxFragment:
+        case SyntaxKind.TaggedTemplateExpression:
+        case SyntaxKind.ArrayLiteralExpression:
+        case SyntaxKind.ParenthesizedExpression:
+        case SyntaxKind.ObjectLiteralExpression:
+        case SyntaxKind.ClassExpression:
+        case SyntaxKind.FunctionExpression:
+        case SyntaxKind.Identifier:
+        case SyntaxKind.PrivateIdentifier: // technically this is only an Expression if it's in a `#field in expr` BinaryExpression
+        case SyntaxKind.RegularExpressionLiteral:
+        case SyntaxKind.NumericLiteral:
+        case SyntaxKind.BigIntLiteral:
+        case SyntaxKind.StringLiteral:
+        case SyntaxKind.NoSubstitutionTemplateLiteral:
+        case SyntaxKind.TemplateExpression:
+        case SyntaxKind.FalseKeyword:
+        case SyntaxKind.NullKeyword:
+        case SyntaxKind.ThisKeyword:
+        case SyntaxKind.TrueKeyword:
+        case SyntaxKind.SuperKeyword:
+        case SyntaxKind.NonNullExpression:
+        case SyntaxKind.ExpressionWithTypeArguments:
+        case SyntaxKind.MetaProperty:
+        case SyntaxKind.ImportKeyword: // technically this is only an Expression if it's in a CallExpression
+        case SyntaxKind.MissingDeclaration:
+            return true;
+        default:
+            return false;
+    }
+}
+export function isUnaryExpression(node) {
+    if (node === undefined)
+        return false;
+    return isUnaryExpressionKind(skipPartiallyEmittedExpressions(node).kind);
+}
+function isUnaryExpressionKind(kind) {
+    switch (kind) {
+        case SyntaxKind.PrefixUnaryExpression:
+        case SyntaxKind.PostfixUnaryExpression:
+        case SyntaxKind.DeleteExpression:
+        case SyntaxKind.TypeOfExpression:
+        case SyntaxKind.VoidExpression:
+        case SyntaxKind.AwaitExpression:
+        case SyntaxKind.TypeAssertionExpression:
+            return true;
+        default:
+            return isLeftHandSideExpressionKind(kind);
+    }
+}
+export function isOuterExpression(node, kinds = OuterExpressionKinds.All) {
+    if (node === undefined)
+        return false;
+    switch (node.kind) {
+        case SyntaxKind.ParenthesizedExpression:
+            if (kinds & OuterExpressionKinds.ExcludeJSDocTypeAssertion && isJSDocTypeAssertion(node)) {
+                return false;
+            }
+            return (kinds & OuterExpressionKinds.Parentheses) !== 0;
+        case SyntaxKind.TypeAssertionExpression:
+        case SyntaxKind.AsExpression:
+            return (kinds & OuterExpressionKinds.TypeAssertions) !== 0;
+        case SyntaxKind.SatisfiesExpression:
+            return (kinds & (OuterExpressionKinds.ExpressionsWithTypeArguments | OuterExpressionKinds.Satisfies)) !== 0;
+        case SyntaxKind.ExpressionWithTypeArguments:
+            return (kinds & OuterExpressionKinds.ExpressionsWithTypeArguments) !== 0;
+        case SyntaxKind.NonNullExpression:
+            return (kinds & OuterExpressionKinds.NonNullAssertions) !== 0;
+        case SyntaxKind.PartiallyEmittedExpression:
+            return (kinds & OuterExpressionKinds.PartiallyEmittedExpressions) !== 0;
+    }
+    return false;
+}
+export function skipOuterExpressions(node, kinds = OuterExpressionKinds.All) {
+    while (isOuterExpression(node, kinds)) {
+        node = node.expression;
+    }
+    return node;
+}
+function isJSDocTypeAssertion(node) {
+    if (node === undefined)
+        return false;
+    const sourceFile = node.getSourceFile();
+    if (sourceFile.scriptKind !== ScriptKind.JS && sourceFile.scriptKind !== ScriptKind.JSX) {
+        return false;
+    }
+    const expression = node.expression;
+    if (expression === undefined || expression.kind !== SyntaxKind.AsExpression) {
+        return false;
+    }
+    const asExpression = expression;
+    return !!asExpression.type
+        && (asExpression.type.flags & NodeFlags.Reparsed) !== 0;
+}
+export function isBindingPattern(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ObjectBindingPattern || node.kind === SyntaxKind.ArrayBindingPattern;
+}
+export function isConciseBody(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.Block || isExpression(node);
+}
+export function isForInitializer(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.VariableDeclarationList || isExpression(node);
+}
+export function isQuestionOrExclamationToken(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.QuestionToken || node.kind === SyntaxKind.ExclamationToken;
+}
+export function isIdentifierOrThisTypeNode(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.ThisType;
+}
+export function isReadonlyKeywordOrPlusOrMinusToken(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.ReadonlyKeyword || node.kind === SyntaxKind.PlusToken || node.kind === SyntaxKind.MinusToken;
+}
+export function isQuestionOrPlusOrMinusToken(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.QuestionToken || node.kind === SyntaxKind.PlusToken || node.kind === SyntaxKind.MinusToken;
+}
+export function isTemplateMiddleOrTemplateTail(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.TemplateMiddle || node.kind === SyntaxKind.TemplateTail;
+}
+export function isLiteralTypeLiteral(node) {
+    if (node === undefined)
+        return false;
+    const kind = node.kind;
+    return kind === SyntaxKind.NullKeyword || kind === SyntaxKind.TrueKeyword
+        || kind === SyntaxKind.FalseKeyword || kind === SyntaxKind.PrefixUnaryExpression
+        || isLiteralExpression(node);
+}
+export function isIdentifierOrJSDocNamespaceDeclaration(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.ModuleDeclaration;
+}
+export function isJSDocTypeExpressionOrJSDocTypeLiteral(node) {
+    if (node === undefined)
+        return false;
+    return node.kind === SyntaxKind.JSDocTypeExpression || node.kind === SyntaxKind.JSDocTypeLiteral;
+}
+export function isJsxTagNameExpression(node) {
+    if (node === undefined)
+        return false;
+    const kind = node.kind;
+    return kind === SyntaxKind.ThisKeyword
+        || kind === SyntaxKind.Identifier
+        || kind === SyntaxKind.PropertyAccessExpression
+        || kind === SyntaxKind.JsxNamespacedName;
+}
+//# sourceMappingURL=ast-guards.generated.js.map