@workday/canvas-kit-docs 9.0.0-alpha.368-next.6 → 9.0.0-alpha.382-next.2

package/dist/es6/docgen/traversals.js

@@ -1,597 +1,596 @@
-var _a;
 // This file is auto-generated from the createTraversals.ts file. Do not modify contents
 import ts from 'typescript';
-export var guards = {
-    isNumericLiteral: function (node) {
+export const guards = {
+    isNumericLiteral(node) {
         return node.kind === ts.SyntaxKind.NumericLiteral;
     },
-    isBigIntLiteral: function (node) {
+    isBigIntLiteral(node) {
         return node.kind === ts.SyntaxKind.BigIntLiteral;
     },
-    isStringLiteral: function (node) {
+    isStringLiteral(node) {
         return node.kind === ts.SyntaxKind.StringLiteral;
     },
-    isJsxText: function (node) {
+    isJsxText(node) {
         return node.kind === ts.SyntaxKind.JsxText;
     },
-    isRegularExpressionLiteral: function (node) {
+    isRegularExpressionLiteral(node) {
         return node.kind === ts.SyntaxKind.RegularExpressionLiteral;
     },
-    isNoSubstitutionTemplateLiteral: function (node) {
+    isNoSubstitutionTemplateLiteral(node) {
         return node.kind === ts.SyntaxKind.NoSubstitutionTemplateLiteral;
     },
-    isTemplateHead: function (node) {
+    isTemplateHead(node) {
         return node.kind === ts.SyntaxKind.TemplateHead;
     },
-    isTemplateMiddle: function (node) {
+    isTemplateMiddle(node) {
         return node.kind === ts.SyntaxKind.TemplateMiddle;
     },
-    isTemplateTail: function (node) {
+    isTemplateTail(node) {
         return node.kind === ts.SyntaxKind.TemplateTail;
     },
-    isIdentifier: function (node) {
+    isIdentifier(node) {
         return node.kind === ts.SyntaxKind.Identifier;
     },
-    isPrivateIdentifier: function (node) {
+    isPrivateIdentifier(node) {
         return node.kind === ts.SyntaxKind.PrivateIdentifier;
     },
-    isFalseKeyword: function (node) {
+    isFalseKeyword(node) {
         return node.kind === ts.SyntaxKind.FalseKeyword;
     },
-    isImportKeyword: function (node) {
+    isImportKeyword(node) {
         return node.kind === ts.SyntaxKind.ImportKeyword;
     },
-    isNullKeyword: function (node) {
+    isNullKeyword(node) {
         return node.kind === ts.SyntaxKind.NullKeyword;
     },
-    isSuperKeyword: function (node) {
+    isSuperKeyword(node) {
         return node.kind === ts.SyntaxKind.SuperKeyword;
     },
-    isThisKeyword: function (node) {
+    isThisKeyword(node) {
         return node.kind === ts.SyntaxKind.ThisKeyword;
     },
-    isTrueKeyword: function (node) {
+    isTrueKeyword(node) {
         return node.kind === ts.SyntaxKind.TrueKeyword;
     },
-    isQualifiedName: function (node) {
+    isQualifiedName(node) {
         return node.kind === ts.SyntaxKind.QualifiedName;
     },
-    isComputedPropertyName: function (node) {
+    isComputedPropertyName(node) {
         return node.kind === ts.SyntaxKind.ComputedPropertyName;
     },
-    isTypeParameter: function (node) {
+    isTypeParameter(node) {
         return node.kind === ts.SyntaxKind.TypeParameter;
     },
-    isParameter: function (node) {
+    isParameter(node) {
         return node.kind === ts.SyntaxKind.Parameter;
     },
-    isDecorator: function (node) {
+    isDecorator(node) {
         return node.kind === ts.SyntaxKind.Decorator;
     },
-    isPropertySignature: function (node) {
+    isPropertySignature(node) {
         return node.kind === ts.SyntaxKind.PropertySignature;
     },
-    isPropertyDeclaration: function (node) {
+    isPropertyDeclaration(node) {
         return node.kind === ts.SyntaxKind.PropertyDeclaration;
     },
-    isMethodSignature: function (node) {
+    isMethodSignature(node) {
         return node.kind === ts.SyntaxKind.MethodSignature;
     },
-    isMethodDeclaration: function (node) {
+    isMethodDeclaration(node) {
         return node.kind === ts.SyntaxKind.MethodDeclaration;
     },
-    isConstructor: function (node) {
+    isConstructor(node) {
         return node.kind === ts.SyntaxKind.Constructor;
     },
-    isGetAccessor: function (node) {
+    isGetAccessor(node) {
         return node.kind === ts.SyntaxKind.GetAccessor;
     },
-    isSetAccessor: function (node) {
+    isSetAccessor(node) {
         return node.kind === ts.SyntaxKind.SetAccessor;
     },
-    isCallSignature: function (node) {
+    isCallSignature(node) {
         return node.kind === ts.SyntaxKind.CallSignature;
     },
-    isConstructSignature: function (node) {
+    isConstructSignature(node) {
         return node.kind === ts.SyntaxKind.ConstructSignature;
     },
-    isIndexSignature: function (node) {
+    isIndexSignature(node) {
         return node.kind === ts.SyntaxKind.IndexSignature;
     },
-    isTypePredicate: function (node) {
+    isTypePredicate(node) {
         return node.kind === ts.SyntaxKind.TypePredicate;
     },
-    isTypeReference: function (node) {
+    isTypeReference(node) {
         return node.kind === ts.SyntaxKind.TypeReference;
     },
-    isFunctionType: function (node) {
+    isFunctionType(node) {
         return node.kind === ts.SyntaxKind.FunctionType;
     },
-    isConstructorType: function (node) {
+    isConstructorType(node) {
         return node.kind === ts.SyntaxKind.ConstructorType;
     },
-    isTypeQuery: function (node) {
+    isTypeQuery(node) {
         return node.kind === ts.SyntaxKind.TypeQuery;
     },
-    isTypeLiteral: function (node) {
+    isTypeLiteral(node) {
         return node.kind === ts.SyntaxKind.TypeLiteral;
     },
-    isArrayType: function (node) {
+    isArrayType(node) {
         return node.kind === ts.SyntaxKind.ArrayType;
     },
-    isTupleType: function (node) {
+    isTupleType(node) {
         return node.kind === ts.SyntaxKind.TupleType;
     },
-    isOptionalType: function (node) {
+    isOptionalType(node) {
         return node.kind === ts.SyntaxKind.OptionalType;
     },
-    isRestType: function (node) {
+    isRestType(node) {
         return node.kind === ts.SyntaxKind.RestType;
     },
-    isUnionType: function (node) {
+    isUnionType(node) {
         return node.kind === ts.SyntaxKind.UnionType;
     },
-    isIntersectionType: function (node) {
+    isIntersectionType(node) {
         return node.kind === ts.SyntaxKind.IntersectionType;
     },
-    isConditionalType: function (node) {
+    isConditionalType(node) {
         return node.kind === ts.SyntaxKind.ConditionalType;
     },
-    isInferType: function (node) {
+    isInferType(node) {
         return node.kind === ts.SyntaxKind.InferType;
     },
-    isParenthesizedType: function (node) {
+    isParenthesizedType(node) {
         return node.kind === ts.SyntaxKind.ParenthesizedType;
     },
-    isThisType: function (node) {
+    isThisType(node) {
         return node.kind === ts.SyntaxKind.ThisType;
     },
-    isTypeOperator: function (node) {
+    isTypeOperator(node) {
         return node.kind === ts.SyntaxKind.TypeOperator;
     },
-    isIndexedAccessType: function (node) {
+    isIndexedAccessType(node) {
         return node.kind === ts.SyntaxKind.IndexedAccessType;
     },
-    isMappedType: function (node) {
+    isMappedType(node) {
         return node.kind === ts.SyntaxKind.MappedType;
     },
-    isLiteralType: function (node) {
+    isLiteralType(node) {
         return node.kind === ts.SyntaxKind.LiteralType;
     },
-    isNamedTupleMember: function (node) {
+    isNamedTupleMember(node) {
         return node.kind === ts.SyntaxKind.NamedTupleMember;
     },
-    isTemplateLiteralType: function (node) {
+    isTemplateLiteralType(node) {
         return node.kind === ts.SyntaxKind.TemplateLiteralType;
     },
-    isTemplateLiteralTypeSpan: function (node) {
+    isTemplateLiteralTypeSpan(node) {
         return node.kind === ts.SyntaxKind.TemplateLiteralTypeSpan;
     },
-    isImportType: function (node) {
+    isImportType(node) {
         return node.kind === ts.SyntaxKind.ImportType;
     },
-    isObjectBindingPattern: function (node) {
+    isObjectBindingPattern(node) {
         return node.kind === ts.SyntaxKind.ObjectBindingPattern;
     },
-    isArrayBindingPattern: function (node) {
+    isArrayBindingPattern(node) {
         return node.kind === ts.SyntaxKind.ArrayBindingPattern;
     },
-    isBindingElement: function (node) {
+    isBindingElement(node) {
         return node.kind === ts.SyntaxKind.BindingElement;
     },
-    isArrayLiteralExpression: function (node) {
+    isArrayLiteralExpression(node) {
         return node.kind === ts.SyntaxKind.ArrayLiteralExpression;
     },
-    isObjectLiteralExpression: function (node) {
+    isObjectLiteralExpression(node) {
         return node.kind === ts.SyntaxKind.ObjectLiteralExpression;
     },
-    isPropertyAccessExpression: function (node) {
+    isPropertyAccessExpression(node) {
         return node.kind === ts.SyntaxKind.PropertyAccessExpression;
     },
-    isElementAccessExpression: function (node) {
+    isElementAccessExpression(node) {
         return node.kind === ts.SyntaxKind.ElementAccessExpression;
     },
-    isCallExpression: function (node) {
+    isCallExpression(node) {
         return node.kind === ts.SyntaxKind.CallExpression;
     },
-    isNewExpression: function (node) {
+    isNewExpression(node) {
         return node.kind === ts.SyntaxKind.NewExpression;
     },
-    isTaggedTemplateExpression: function (node) {
+    isTaggedTemplateExpression(node) {
         return node.kind === ts.SyntaxKind.TaggedTemplateExpression;
     },
-    isTypeAssertionExpression: function (node) {
+    isTypeAssertionExpression(node) {
         return node.kind === ts.SyntaxKind.TypeAssertionExpression;
     },
-    isParenthesizedExpression: function (node) {
+    isParenthesizedExpression(node) {
         return node.kind === ts.SyntaxKind.ParenthesizedExpression;
     },
-    isFunctionExpression: function (node) {
+    isFunctionExpression(node) {
         return node.kind === ts.SyntaxKind.FunctionExpression;
     },
-    isArrowFunction: function (node) {
+    isArrowFunction(node) {
         return node.kind === ts.SyntaxKind.ArrowFunction;
     },
-    isDeleteExpression: function (node) {
+    isDeleteExpression(node) {
         return node.kind === ts.SyntaxKind.DeleteExpression;
     },
-    isTypeOfExpression: function (node) {
+    isTypeOfExpression(node) {
         return node.kind === ts.SyntaxKind.TypeOfExpression;
     },
-    isVoidExpression: function (node) {
+    isVoidExpression(node) {
         return node.kind === ts.SyntaxKind.VoidExpression;
     },
-    isAwaitExpression: function (node) {
+    isAwaitExpression(node) {
         return node.kind === ts.SyntaxKind.AwaitExpression;
     },
-    isPrefixUnaryExpression: function (node) {
+    isPrefixUnaryExpression(node) {
         return node.kind === ts.SyntaxKind.PrefixUnaryExpression;
     },
-    isPostfixUnaryExpression: function (node) {
+    isPostfixUnaryExpression(node) {
         return node.kind === ts.SyntaxKind.PostfixUnaryExpression;
     },
-    isBinaryExpression: function (node) {
+    isBinaryExpression(node) {
         return node.kind === ts.SyntaxKind.BinaryExpression;
     },
-    isConditionalExpression: function (node) {
+    isConditionalExpression(node) {
         return node.kind === ts.SyntaxKind.ConditionalExpression;
     },
-    isTemplateExpression: function (node) {
+    isTemplateExpression(node) {
         return node.kind === ts.SyntaxKind.TemplateExpression;
     },
-    isYieldExpression: function (node) {
+    isYieldExpression(node) {
         return node.kind === ts.SyntaxKind.YieldExpression;
     },
-    isSpreadElement: function (node) {
+    isSpreadElement(node) {
         return node.kind === ts.SyntaxKind.SpreadElement;
     },
-    isClassExpression: function (node) {
+    isClassExpression(node) {
         return node.kind === ts.SyntaxKind.ClassExpression;
     },
-    isOmittedExpression: function (node) {
+    isOmittedExpression(node) {
         return node.kind === ts.SyntaxKind.OmittedExpression;
     },
-    isExpressionWithTypeArguments: function (node) {
+    isExpressionWithTypeArguments(node) {
         return node.kind === ts.SyntaxKind.ExpressionWithTypeArguments;
     },
-    isAsExpression: function (node) {
+    isAsExpression(node) {
         return node.kind === ts.SyntaxKind.AsExpression;
     },
-    isNonNullExpression: function (node) {
+    isNonNullExpression(node) {
         return node.kind === ts.SyntaxKind.NonNullExpression;
     },
-    isMetaProperty: function (node) {
+    isMetaProperty(node) {
         return node.kind === ts.SyntaxKind.MetaProperty;
     },
-    isSyntheticExpression: function (node) {
+    isSyntheticExpression(node) {
         return node.kind === ts.SyntaxKind.SyntheticExpression;
     },
-    isTemplateSpan: function (node) {
+    isTemplateSpan(node) {
         return node.kind === ts.SyntaxKind.TemplateSpan;
     },
-    isSemicolonClassElement: function (node) {
+    isSemicolonClassElement(node) {
         return node.kind === ts.SyntaxKind.SemicolonClassElement;
     },
-    isBlock: function (node) {
+    isBlock(node) {
         return node.kind === ts.SyntaxKind.Block;
     },
-    isEmptyStatement: function (node) {
+    isEmptyStatement(node) {
         return node.kind === ts.SyntaxKind.EmptyStatement;
     },
-    isVariableStatement: function (node) {
+    isVariableStatement(node) {
         return node.kind === ts.SyntaxKind.VariableStatement;
     },
-    isExpressionStatement: function (node) {
+    isExpressionStatement(node) {
         return node.kind === ts.SyntaxKind.ExpressionStatement;
     },
-    isIfStatement: function (node) {
+    isIfStatement(node) {
         return node.kind === ts.SyntaxKind.IfStatement;
     },
-    isDoStatement: function (node) {
+    isDoStatement(node) {
         return node.kind === ts.SyntaxKind.DoStatement;
     },
-    isWhileStatement: function (node) {
+    isWhileStatement(node) {
         return node.kind === ts.SyntaxKind.WhileStatement;
     },
-    isForStatement: function (node) {
+    isForStatement(node) {
         return node.kind === ts.SyntaxKind.ForStatement;
     },
-    isForInStatement: function (node) {
+    isForInStatement(node) {
         return node.kind === ts.SyntaxKind.ForInStatement;
     },
-    isForOfStatement: function (node) {
+    isForOfStatement(node) {
         return node.kind === ts.SyntaxKind.ForOfStatement;
     },
-    isContinueStatement: function (node) {
+    isContinueStatement(node) {
         return node.kind === ts.SyntaxKind.ContinueStatement;
     },
-    isBreakStatement: function (node) {
+    isBreakStatement(node) {
         return node.kind === ts.SyntaxKind.BreakStatement;
     },
-    isReturnStatement: function (node) {
+    isReturnStatement(node) {
         return node.kind === ts.SyntaxKind.ReturnStatement;
     },
-    isWithStatement: function (node) {
+    isWithStatement(node) {
         return node.kind === ts.SyntaxKind.WithStatement;
     },
-    isSwitchStatement: function (node) {
+    isSwitchStatement(node) {
         return node.kind === ts.SyntaxKind.SwitchStatement;
     },
-    isLabeledStatement: function (node) {
+    isLabeledStatement(node) {
         return node.kind === ts.SyntaxKind.LabeledStatement;
     },
-    isThrowStatement: function (node) {
+    isThrowStatement(node) {
         return node.kind === ts.SyntaxKind.ThrowStatement;
     },
-    isTryStatement: function (node) {
+    isTryStatement(node) {
         return node.kind === ts.SyntaxKind.TryStatement;
     },
-    isDebuggerStatement: function (node) {
+    isDebuggerStatement(node) {
         return node.kind === ts.SyntaxKind.DebuggerStatement;
     },
-    isVariableDeclaration: function (node) {
+    isVariableDeclaration(node) {
         return node.kind === ts.SyntaxKind.VariableDeclaration;
     },
-    isVariableDeclarationList: function (node) {
+    isVariableDeclarationList(node) {
         return node.kind === ts.SyntaxKind.VariableDeclarationList;
     },
-    isFunctionDeclaration: function (node) {
+    isFunctionDeclaration(node) {
         return node.kind === ts.SyntaxKind.FunctionDeclaration;
     },
-    isClassDeclaration: function (node) {
+    isClassDeclaration(node) {
         return node.kind === ts.SyntaxKind.ClassDeclaration;
     },
-    isInterfaceDeclaration: function (node) {
+    isInterfaceDeclaration(node) {
         return node.kind === ts.SyntaxKind.InterfaceDeclaration;
     },
-    isTypeAliasDeclaration: function (node) {
+    isTypeAliasDeclaration(node) {
         return node.kind === ts.SyntaxKind.TypeAliasDeclaration;
     },
-    isEnumDeclaration: function (node) {
+    isEnumDeclaration(node) {
         return node.kind === ts.SyntaxKind.EnumDeclaration;
     },
-    isModuleDeclaration: function (node) {
+    isModuleDeclaration(node) {
         return node.kind === ts.SyntaxKind.ModuleDeclaration;
     },
-    isModuleBlock: function (node) {
+    isModuleBlock(node) {
         return node.kind === ts.SyntaxKind.ModuleBlock;
     },
-    isCaseBlock: function (node) {
+    isCaseBlock(node) {
         return node.kind === ts.SyntaxKind.CaseBlock;
     },
-    isNamespaceExportDeclaration: function (node) {
+    isNamespaceExportDeclaration(node) {
         return node.kind === ts.SyntaxKind.NamespaceExportDeclaration;
     },
-    isImportEqualsDeclaration: function (node) {
+    isImportEqualsDeclaration(node) {
         return node.kind === ts.SyntaxKind.ImportEqualsDeclaration;
     },
-    isImportDeclaration: function (node) {
+    isImportDeclaration(node) {
         return node.kind === ts.SyntaxKind.ImportDeclaration;
     },
-    isImportClause: function (node) {
+    isImportClause(node) {
         return node.kind === ts.SyntaxKind.ImportClause;
     },
-    isNamespaceImport: function (node) {
+    isNamespaceImport(node) {
         return node.kind === ts.SyntaxKind.NamespaceImport;
     },
-    isNamedImports: function (node) {
+    isNamedImports(node) {
         return node.kind === ts.SyntaxKind.NamedImports;
     },
-    isImportSpecifier: function (node) {
+    isImportSpecifier(node) {
         return node.kind === ts.SyntaxKind.ImportSpecifier;
     },
-    isExportAssignment: function (node) {
+    isExportAssignment(node) {
         return node.kind === ts.SyntaxKind.ExportAssignment;
     },
-    isExportDeclaration: function (node) {
+    isExportDeclaration(node) {
         return node.kind === ts.SyntaxKind.ExportDeclaration;
     },
-    isNamedExports: function (node) {
+    isNamedExports(node) {
         return node.kind === ts.SyntaxKind.NamedExports;
     },
-    isNamespaceExport: function (node) {
+    isNamespaceExport(node) {
         return node.kind === ts.SyntaxKind.NamespaceExport;
     },
-    isExportSpecifier: function (node) {
+    isExportSpecifier(node) {
         return node.kind === ts.SyntaxKind.ExportSpecifier;
     },
-    isMissingDeclaration: function (node) {
+    isMissingDeclaration(node) {
         return node.kind === ts.SyntaxKind.MissingDeclaration;
     },
-    isExternalModuleReference: function (node) {
+    isExternalModuleReference(node) {
         return node.kind === ts.SyntaxKind.ExternalModuleReference;
     },
-    isJsxElement: function (node) {
+    isJsxElement(node) {
         return node.kind === ts.SyntaxKind.JsxElement;
     },
-    isJsxSelfClosingElement: function (node) {
+    isJsxSelfClosingElement(node) {
         return node.kind === ts.SyntaxKind.JsxSelfClosingElement;
     },
-    isJsxOpeningElement: function (node) {
+    isJsxOpeningElement(node) {
         return node.kind === ts.SyntaxKind.JsxOpeningElement;
     },
-    isJsxClosingElement: function (node) {
+    isJsxClosingElement(node) {
         return node.kind === ts.SyntaxKind.JsxClosingElement;
     },
-    isJsxFragment: function (node) {
+    isJsxFragment(node) {
         return node.kind === ts.SyntaxKind.JsxFragment;
     },
-    isJsxOpeningFragment: function (node) {
+    isJsxOpeningFragment(node) {
         return node.kind === ts.SyntaxKind.JsxOpeningFragment;
     },
-    isJsxClosingFragment: function (node) {
+    isJsxClosingFragment(node) {
         return node.kind === ts.SyntaxKind.JsxClosingFragment;
     },
-    isJsxAttribute: function (node) {
+    isJsxAttribute(node) {
         return node.kind === ts.SyntaxKind.JsxAttribute;
     },
-    isJsxAttributes: function (node) {
+    isJsxAttributes(node) {
         return node.kind === ts.SyntaxKind.JsxAttributes;
     },
-    isJsxSpreadAttribute: function (node) {
+    isJsxSpreadAttribute(node) {
         return node.kind === ts.SyntaxKind.JsxSpreadAttribute;
     },
-    isJsxExpression: function (node) {
+    isJsxExpression(node) {
         return node.kind === ts.SyntaxKind.JsxExpression;
     },
-    isCaseClause: function (node) {
+    isCaseClause(node) {
         return node.kind === ts.SyntaxKind.CaseClause;
     },
-    isDefaultClause: function (node) {
+    isDefaultClause(node) {
         return node.kind === ts.SyntaxKind.DefaultClause;
     },
-    isHeritageClause: function (node) {
+    isHeritageClause(node) {
         return node.kind === ts.SyntaxKind.HeritageClause;
     },
-    isCatchClause: function (node) {
+    isCatchClause(node) {
         return node.kind === ts.SyntaxKind.CatchClause;
     },
-    isPropertyAssignment: function (node) {
+    isPropertyAssignment(node) {
         return node.kind === ts.SyntaxKind.PropertyAssignment;
     },
-    isShorthandPropertyAssignment: function (node) {
+    isShorthandPropertyAssignment(node) {
         return node.kind === ts.SyntaxKind.ShorthandPropertyAssignment;
     },
-    isSpreadAssignment: function (node) {
+    isSpreadAssignment(node) {
         return node.kind === ts.SyntaxKind.SpreadAssignment;
     },
-    isEnumMember: function (node) {
+    isEnumMember(node) {
         return node.kind === ts.SyntaxKind.EnumMember;
     },
-    isUnparsedPrologue: function (node) {
+    isUnparsedPrologue(node) {
         return node.kind === ts.SyntaxKind.UnparsedPrologue;
     },
-    isUnparsedPrepend: function (node) {
+    isUnparsedPrepend(node) {
         return node.kind === ts.SyntaxKind.UnparsedPrepend;
     },
-    isUnparsedSyntheticReference: function (node) {
+    isUnparsedSyntheticReference(node) {
         return node.kind === ts.SyntaxKind.UnparsedSyntheticReference;
     },
-    isSourceFile: function (node) {
+    isSourceFile(node) {
         return node.kind === ts.SyntaxKind.SourceFile;
     },
-    isBundle: function (node) {
+    isBundle(node) {
         return node.kind === ts.SyntaxKind.Bundle;
     },
-    isUnparsedSource: function (node) {
+    isUnparsedSource(node) {
         return node.kind === ts.SyntaxKind.UnparsedSource;
     },
-    isInputFiles: function (node) {
+    isInputFiles(node) {
         return node.kind === ts.SyntaxKind.InputFiles;
     },
-    isJSDocTypeExpression: function (node) {
+    isJSDocTypeExpression(node) {
         return node.kind === ts.SyntaxKind.JSDocTypeExpression;
     },
-    isJSDocNameReference: function (node) {
+    isJSDocNameReference(node) {
         return node.kind === ts.SyntaxKind.JSDocNameReference;
     },
-    isJSDocAllType: function (node) {
+    isJSDocAllType(node) {
         return node.kind === ts.SyntaxKind.JSDocAllType;
     },
-    isJSDocUnknownType: function (node) {
+    isJSDocUnknownType(node) {
         return node.kind === ts.SyntaxKind.JSDocUnknownType;
     },
-    isJSDocNullableType: function (node) {
+    isJSDocNullableType(node) {
         return node.kind === ts.SyntaxKind.JSDocNullableType;
     },
-    isJSDocNonNullableType: function (node) {
+    isJSDocNonNullableType(node) {
         return node.kind === ts.SyntaxKind.JSDocNonNullableType;
     },
-    isJSDocOptionalType: function (node) {
+    isJSDocOptionalType(node) {
         return node.kind === ts.SyntaxKind.JSDocOptionalType;
     },
-    isJSDocFunctionType: function (node) {
+    isJSDocFunctionType(node) {
         return node.kind === ts.SyntaxKind.JSDocFunctionType;
     },
-    isJSDocVariadicType: function (node) {
+    isJSDocVariadicType(node) {
         return node.kind === ts.SyntaxKind.JSDocVariadicType;
     },
-    isJSDocNamepathType: function (node) {
+    isJSDocNamepathType(node) {
         return node.kind === ts.SyntaxKind.JSDocNamepathType;
     },
-    isJSDocComment: function (node) {
+    isJSDocComment(node) {
         return node.kind === ts.SyntaxKind.JSDocComment;
     },
-    isJSDocTypeLiteral: function (node) {
+    isJSDocTypeLiteral(node) {
         return node.kind === ts.SyntaxKind.JSDocTypeLiteral;
     },
-    isJSDocSignature: function (node) {
+    isJSDocSignature(node) {
         return node.kind === ts.SyntaxKind.JSDocSignature;
     },
-    isJSDocTag: function (node) {
+    isJSDocTag(node) {
         return node.kind === ts.SyntaxKind.JSDocTag;
     },
-    isJSDocAugmentsTag: function (node) {
+    isJSDocAugmentsTag(node) {
         return node.kind === ts.SyntaxKind.JSDocAugmentsTag;
     },
-    isJSDocImplementsTag: function (node) {
+    isJSDocImplementsTag(node) {
         return node.kind === ts.SyntaxKind.JSDocImplementsTag;
     },
-    isJSDocAuthorTag: function (node) {
+    isJSDocAuthorTag(node) {
         return node.kind === ts.SyntaxKind.JSDocAuthorTag;
     },
-    isJSDocDeprecatedTag: function (node) {
+    isJSDocDeprecatedTag(node) {
         return node.kind === ts.SyntaxKind.JSDocDeprecatedTag;
     },
-    isJSDocClassTag: function (node) {
+    isJSDocClassTag(node) {
         return node.kind === ts.SyntaxKind.JSDocClassTag;
     },
-    isJSDocPublicTag: function (node) {
+    isJSDocPublicTag(node) {
         return node.kind === ts.SyntaxKind.JSDocPublicTag;
     },
-    isJSDocPrivateTag: function (node) {
+    isJSDocPrivateTag(node) {
         return node.kind === ts.SyntaxKind.JSDocPrivateTag;
     },
-    isJSDocProtectedTag: function (node) {
+    isJSDocProtectedTag(node) {
         return node.kind === ts.SyntaxKind.JSDocProtectedTag;
     },
-    isJSDocReadonlyTag: function (node) {
+    isJSDocReadonlyTag(node) {
         return node.kind === ts.SyntaxKind.JSDocReadonlyTag;
     },
-    isJSDocCallbackTag: function (node) {
+    isJSDocCallbackTag(node) {
         return node.kind === ts.SyntaxKind.JSDocCallbackTag;
     },
-    isJSDocEnumTag: function (node) {
+    isJSDocEnumTag(node) {
         return node.kind === ts.SyntaxKind.JSDocEnumTag;
     },
-    isJSDocParameterTag: function (node) {
+    isJSDocParameterTag(node) {
         return node.kind === ts.SyntaxKind.JSDocParameterTag;
     },
-    isJSDocReturnTag: function (node) {
+    isJSDocReturnTag(node) {
         return node.kind === ts.SyntaxKind.JSDocReturnTag;
     },
-    isJSDocThisTag: function (node) {
+    isJSDocThisTag(node) {
         return node.kind === ts.SyntaxKind.JSDocThisTag;
     },
-    isJSDocTypeTag: function (node) {
+    isJSDocTypeTag(node) {
         return node.kind === ts.SyntaxKind.JSDocTypeTag;
     },
-    isJSDocTemplateTag: function (node) {
+    isJSDocTemplateTag(node) {
         return node.kind === ts.SyntaxKind.JSDocTemplateTag;
     },
-    isJSDocTypedefTag: function (node) {
+    isJSDocTypedefTag(node) {
         return node.kind === ts.SyntaxKind.JSDocTypedefTag;
     },
-    isJSDocSeeTag: function (node) {
+    isJSDocSeeTag(node) {
         return node.kind === ts.SyntaxKind.JSDocSeeTag;
     },
-    isJSDocPropertyTag: function (node) {
+    isJSDocPropertyTag(node) {
         return node.kind === ts.SyntaxKind.JSDocPropertyTag;
     },
-    isSyntaxList: function (node) {
+    isSyntaxList(node) {
         return node.kind === ts.SyntaxKind.SyntaxList;
     },
-    isNotEmittedStatement: function (node) {
+    isNotEmittedStatement(node) {
         return node.kind === ts.SyntaxKind.NotEmittedStatement;
     },
-    isPartiallyEmittedExpression: function (node) {
+    isPartiallyEmittedExpression(node) {
         return node.kind === ts.SyntaxKind.PartiallyEmittedExpression;
     },
-    isCommaListExpression: function (node) {
+    isCommaListExpression(node) {
         return node.kind === ts.SyntaxKind.CommaListExpression;
     },
 };
-export var kindsMap = {
+export const kindsMap = {
     NumericLiteral: {},
     BigIntLiteral: {},
     StringLiteral: {},
@@ -789,204 +788,204 @@ export var kindsMap = {
     PartiallyEmittedExpression: {},
     CommaListExpression: {},
 };
-var kindToString = (_a = {},
-    _a[ts.SyntaxKind.NumericLiteral] = 'NumericLiteral',
-    _a[ts.SyntaxKind.BigIntLiteral] = 'BigIntLiteral',
-    _a[ts.SyntaxKind.StringLiteral] = 'StringLiteral',
-    _a[ts.SyntaxKind.JsxText] = 'JsxText',
-    _a[ts.SyntaxKind.RegularExpressionLiteral] = 'RegularExpressionLiteral',
-    _a[ts.SyntaxKind.NoSubstitutionTemplateLiteral] = 'NoSubstitutionTemplateLiteral',
-    _a[ts.SyntaxKind.TemplateHead] = 'TemplateHead',
-    _a[ts.SyntaxKind.TemplateMiddle] = 'TemplateMiddle',
-    _a[ts.SyntaxKind.TemplateTail] = 'TemplateTail',
-    _a[ts.SyntaxKind.Identifier] = 'Identifier',
-    _a[ts.SyntaxKind.PrivateIdentifier] = 'PrivateIdentifier',
-    _a[ts.SyntaxKind.FalseKeyword] = 'FalseKeyword',
-    _a[ts.SyntaxKind.ImportKeyword] = 'ImportKeyword',
-    _a[ts.SyntaxKind.NullKeyword] = 'NullKeyword',
-    _a[ts.SyntaxKind.SuperKeyword] = 'SuperKeyword',
-    _a[ts.SyntaxKind.ThisKeyword] = 'ThisKeyword',
-    _a[ts.SyntaxKind.TrueKeyword] = 'TrueKeyword',
-    _a[ts.SyntaxKind.QualifiedName] = 'QualifiedName',
-    _a[ts.SyntaxKind.ComputedPropertyName] = 'ComputedPropertyName',
-    _a[ts.SyntaxKind.TypeParameter] = 'TypeParameter',
-    _a[ts.SyntaxKind.Parameter] = 'Parameter',
-    _a[ts.SyntaxKind.Decorator] = 'Decorator',
-    _a[ts.SyntaxKind.PropertySignature] = 'PropertySignature',
-    _a[ts.SyntaxKind.PropertyDeclaration] = 'PropertyDeclaration',
-    _a[ts.SyntaxKind.MethodSignature] = 'MethodSignature',
-    _a[ts.SyntaxKind.MethodDeclaration] = 'MethodDeclaration',
-    _a[ts.SyntaxKind.Constructor] = 'Constructor',
-    _a[ts.SyntaxKind.GetAccessor] = 'GetAccessor',
-    _a[ts.SyntaxKind.SetAccessor] = 'SetAccessor',
-    _a[ts.SyntaxKind.CallSignature] = 'CallSignature',
-    _a[ts.SyntaxKind.ConstructSignature] = 'ConstructSignature',
-    _a[ts.SyntaxKind.IndexSignature] = 'IndexSignature',
-    _a[ts.SyntaxKind.TypePredicate] = 'TypePredicate',
-    _a[ts.SyntaxKind.TypeReference] = 'TypeReference',
-    _a[ts.SyntaxKind.FunctionType] = 'FunctionType',
-    _a[ts.SyntaxKind.ConstructorType] = 'ConstructorType',
-    _a[ts.SyntaxKind.TypeQuery] = 'TypeQuery',
-    _a[ts.SyntaxKind.TypeLiteral] = 'TypeLiteral',
-    _a[ts.SyntaxKind.ArrayType] = 'ArrayType',
-    _a[ts.SyntaxKind.TupleType] = 'TupleType',
-    _a[ts.SyntaxKind.OptionalType] = 'OptionalType',
-    _a[ts.SyntaxKind.RestType] = 'RestType',
-    _a[ts.SyntaxKind.UnionType] = 'UnionType',
-    _a[ts.SyntaxKind.IntersectionType] = 'IntersectionType',
-    _a[ts.SyntaxKind.ConditionalType] = 'ConditionalType',
-    _a[ts.SyntaxKind.InferType] = 'InferType',
-    _a[ts.SyntaxKind.ParenthesizedType] = 'ParenthesizedType',
-    _a[ts.SyntaxKind.ThisType] = 'ThisType',
-    _a[ts.SyntaxKind.TypeOperator] = 'TypeOperator',
-    _a[ts.SyntaxKind.IndexedAccessType] = 'IndexedAccessType',
-    _a[ts.SyntaxKind.MappedType] = 'MappedType',
-    _a[ts.SyntaxKind.LiteralType] = 'LiteralType',
-    _a[ts.SyntaxKind.NamedTupleMember] = 'NamedTupleMember',
-    _a[ts.SyntaxKind.TemplateLiteralType] = 'TemplateLiteralType',
-    _a[ts.SyntaxKind.TemplateLiteralTypeSpan] = 'TemplateLiteralTypeSpan',
-    _a[ts.SyntaxKind.ImportType] = 'ImportType',
-    _a[ts.SyntaxKind.ObjectBindingPattern] = 'ObjectBindingPattern',
-    _a[ts.SyntaxKind.ArrayBindingPattern] = 'ArrayBindingPattern',
-    _a[ts.SyntaxKind.BindingElement] = 'BindingElement',
-    _a[ts.SyntaxKind.ArrayLiteralExpression] = 'ArrayLiteralExpression',
-    _a[ts.SyntaxKind.ObjectLiteralExpression] = 'ObjectLiteralExpression',
-    _a[ts.SyntaxKind.PropertyAccessExpression] = 'PropertyAccessExpression',
-    _a[ts.SyntaxKind.ElementAccessExpression] = 'ElementAccessExpression',
-    _a[ts.SyntaxKind.CallExpression] = 'CallExpression',
-    _a[ts.SyntaxKind.NewExpression] = 'NewExpression',
-    _a[ts.SyntaxKind.TaggedTemplateExpression] = 'TaggedTemplateExpression',
-    _a[ts.SyntaxKind.TypeAssertionExpression] = 'TypeAssertionExpression',
-    _a[ts.SyntaxKind.ParenthesizedExpression] = 'ParenthesizedExpression',
-    _a[ts.SyntaxKind.FunctionExpression] = 'FunctionExpression',
-    _a[ts.SyntaxKind.ArrowFunction] = 'ArrowFunction',
-    _a[ts.SyntaxKind.DeleteExpression] = 'DeleteExpression',
-    _a[ts.SyntaxKind.TypeOfExpression] = 'TypeOfExpression',
-    _a[ts.SyntaxKind.VoidExpression] = 'VoidExpression',
-    _a[ts.SyntaxKind.AwaitExpression] = 'AwaitExpression',
-    _a[ts.SyntaxKind.PrefixUnaryExpression] = 'PrefixUnaryExpression',
-    _a[ts.SyntaxKind.PostfixUnaryExpression] = 'PostfixUnaryExpression',
-    _a[ts.SyntaxKind.BinaryExpression] = 'BinaryExpression',
-    _a[ts.SyntaxKind.ConditionalExpression] = 'ConditionalExpression',
-    _a[ts.SyntaxKind.TemplateExpression] = 'TemplateExpression',
-    _a[ts.SyntaxKind.YieldExpression] = 'YieldExpression',
-    _a[ts.SyntaxKind.SpreadElement] = 'SpreadElement',
-    _a[ts.SyntaxKind.ClassExpression] = 'ClassExpression',
-    _a[ts.SyntaxKind.OmittedExpression] = 'OmittedExpression',
-    _a[ts.SyntaxKind.ExpressionWithTypeArguments] = 'ExpressionWithTypeArguments',
-    _a[ts.SyntaxKind.AsExpression] = 'AsExpression',
-    _a[ts.SyntaxKind.NonNullExpression] = 'NonNullExpression',
-    _a[ts.SyntaxKind.MetaProperty] = 'MetaProperty',
-    _a[ts.SyntaxKind.SyntheticExpression] = 'SyntheticExpression',
-    _a[ts.SyntaxKind.TemplateSpan] = 'TemplateSpan',
-    _a[ts.SyntaxKind.SemicolonClassElement] = 'SemicolonClassElement',
-    _a[ts.SyntaxKind.Block] = 'Block',
-    _a[ts.SyntaxKind.EmptyStatement] = 'EmptyStatement',
-    _a[ts.SyntaxKind.VariableStatement] = 'VariableStatement',
-    _a[ts.SyntaxKind.ExpressionStatement] = 'ExpressionStatement',
-    _a[ts.SyntaxKind.IfStatement] = 'IfStatement',
-    _a[ts.SyntaxKind.DoStatement] = 'DoStatement',
-    _a[ts.SyntaxKind.WhileStatement] = 'WhileStatement',
-    _a[ts.SyntaxKind.ForStatement] = 'ForStatement',
-    _a[ts.SyntaxKind.ForInStatement] = 'ForInStatement',
-    _a[ts.SyntaxKind.ForOfStatement] = 'ForOfStatement',
-    _a[ts.SyntaxKind.ContinueStatement] = 'ContinueStatement',
-    _a[ts.SyntaxKind.BreakStatement] = 'BreakStatement',
-    _a[ts.SyntaxKind.ReturnStatement] = 'ReturnStatement',
-    _a[ts.SyntaxKind.WithStatement] = 'WithStatement',
-    _a[ts.SyntaxKind.SwitchStatement] = 'SwitchStatement',
-    _a[ts.SyntaxKind.LabeledStatement] = 'LabeledStatement',
-    _a[ts.SyntaxKind.ThrowStatement] = 'ThrowStatement',
-    _a[ts.SyntaxKind.TryStatement] = 'TryStatement',
-    _a[ts.SyntaxKind.DebuggerStatement] = 'DebuggerStatement',
-    _a[ts.SyntaxKind.VariableDeclaration] = 'VariableDeclaration',
-    _a[ts.SyntaxKind.VariableDeclarationList] = 'VariableDeclarationList',
-    _a[ts.SyntaxKind.FunctionDeclaration] = 'FunctionDeclaration',
-    _a[ts.SyntaxKind.ClassDeclaration] = 'ClassDeclaration',
-    _a[ts.SyntaxKind.InterfaceDeclaration] = 'InterfaceDeclaration',
-    _a[ts.SyntaxKind.TypeAliasDeclaration] = 'TypeAliasDeclaration',
-    _a[ts.SyntaxKind.EnumDeclaration] = 'EnumDeclaration',
-    _a[ts.SyntaxKind.ModuleDeclaration] = 'ModuleDeclaration',
-    _a[ts.SyntaxKind.ModuleBlock] = 'ModuleBlock',
-    _a[ts.SyntaxKind.CaseBlock] = 'CaseBlock',
-    _a[ts.SyntaxKind.NamespaceExportDeclaration] = 'NamespaceExportDeclaration',
-    _a[ts.SyntaxKind.ImportEqualsDeclaration] = 'ImportEqualsDeclaration',
-    _a[ts.SyntaxKind.ImportDeclaration] = 'ImportDeclaration',
-    _a[ts.SyntaxKind.ImportClause] = 'ImportClause',
-    _a[ts.SyntaxKind.NamespaceImport] = 'NamespaceImport',
-    _a[ts.SyntaxKind.NamedImports] = 'NamedImports',
-    _a[ts.SyntaxKind.ImportSpecifier] = 'ImportSpecifier',
-    _a[ts.SyntaxKind.ExportAssignment] = 'ExportAssignment',
-    _a[ts.SyntaxKind.ExportDeclaration] = 'ExportDeclaration',
-    _a[ts.SyntaxKind.NamedExports] = 'NamedExports',
-    _a[ts.SyntaxKind.NamespaceExport] = 'NamespaceExport',
-    _a[ts.SyntaxKind.ExportSpecifier] = 'ExportSpecifier',
-    _a[ts.SyntaxKind.MissingDeclaration] = 'MissingDeclaration',
-    _a[ts.SyntaxKind.ExternalModuleReference] = 'ExternalModuleReference',
-    _a[ts.SyntaxKind.JsxElement] = 'JsxElement',
-    _a[ts.SyntaxKind.JsxSelfClosingElement] = 'JsxSelfClosingElement',
-    _a[ts.SyntaxKind.JsxOpeningElement] = 'JsxOpeningElement',
-    _a[ts.SyntaxKind.JsxClosingElement] = 'JsxClosingElement',
-    _a[ts.SyntaxKind.JsxFragment] = 'JsxFragment',
-    _a[ts.SyntaxKind.JsxOpeningFragment] = 'JsxOpeningFragment',
-    _a[ts.SyntaxKind.JsxClosingFragment] = 'JsxClosingFragment',
-    _a[ts.SyntaxKind.JsxAttribute] = 'JsxAttribute',
-    _a[ts.SyntaxKind.JsxAttributes] = 'JsxAttributes',
-    _a[ts.SyntaxKind.JsxSpreadAttribute] = 'JsxSpreadAttribute',
-    _a[ts.SyntaxKind.JsxExpression] = 'JsxExpression',
-    _a[ts.SyntaxKind.CaseClause] = 'CaseClause',
-    _a[ts.SyntaxKind.DefaultClause] = 'DefaultClause',
-    _a[ts.SyntaxKind.HeritageClause] = 'HeritageClause',
-    _a[ts.SyntaxKind.CatchClause] = 'CatchClause',
-    _a[ts.SyntaxKind.PropertyAssignment] = 'PropertyAssignment',
-    _a[ts.SyntaxKind.ShorthandPropertyAssignment] = 'ShorthandPropertyAssignment',
-    _a[ts.SyntaxKind.SpreadAssignment] = 'SpreadAssignment',
-    _a[ts.SyntaxKind.EnumMember] = 'EnumMember',
-    _a[ts.SyntaxKind.UnparsedPrologue] = 'UnparsedPrologue',
-    _a[ts.SyntaxKind.UnparsedPrepend] = 'UnparsedPrepend',
-    _a[ts.SyntaxKind.UnparsedSyntheticReference] = 'UnparsedSyntheticReference',
-    _a[ts.SyntaxKind.SourceFile] = 'SourceFile',
-    _a[ts.SyntaxKind.Bundle] = 'Bundle',
-    _a[ts.SyntaxKind.UnparsedSource] = 'UnparsedSource',
-    _a[ts.SyntaxKind.InputFiles] = 'InputFiles',
-    _a[ts.SyntaxKind.JSDocTypeExpression] = 'JSDocTypeExpression',
-    _a[ts.SyntaxKind.JSDocNameReference] = 'JSDocNameReference',
-    _a[ts.SyntaxKind.JSDocAllType] = 'JSDocAllType',
-    _a[ts.SyntaxKind.JSDocUnknownType] = 'JSDocUnknownType',
-    _a[ts.SyntaxKind.JSDocNullableType] = 'JSDocNullableType',
-    _a[ts.SyntaxKind.JSDocNonNullableType] = 'JSDocNonNullableType',
-    _a[ts.SyntaxKind.JSDocOptionalType] = 'JSDocOptionalType',
-    _a[ts.SyntaxKind.JSDocFunctionType] = 'JSDocFunctionType',
-    _a[ts.SyntaxKind.JSDocVariadicType] = 'JSDocVariadicType',
-    _a[ts.SyntaxKind.JSDocNamepathType] = 'JSDocNamepathType',
-    _a[ts.SyntaxKind.JSDocComment] = 'JSDocComment',
-    _a[ts.SyntaxKind.JSDocTypeLiteral] = 'JSDocTypeLiteral',
-    _a[ts.SyntaxKind.JSDocSignature] = 'JSDocSignature',
-    _a[ts.SyntaxKind.JSDocTag] = 'JSDocTag',
-    _a[ts.SyntaxKind.JSDocAugmentsTag] = 'JSDocAugmentsTag',
-    _a[ts.SyntaxKind.JSDocImplementsTag] = 'JSDocImplementsTag',
-    _a[ts.SyntaxKind.JSDocAuthorTag] = 'JSDocAuthorTag',
-    _a[ts.SyntaxKind.JSDocDeprecatedTag] = 'JSDocDeprecatedTag',
-    _a[ts.SyntaxKind.JSDocClassTag] = 'JSDocClassTag',
-    _a[ts.SyntaxKind.JSDocPublicTag] = 'JSDocPublicTag',
-    _a[ts.SyntaxKind.JSDocPrivateTag] = 'JSDocPrivateTag',
-    _a[ts.SyntaxKind.JSDocProtectedTag] = 'JSDocProtectedTag',
-    _a[ts.SyntaxKind.JSDocReadonlyTag] = 'JSDocReadonlyTag',
-    _a[ts.SyntaxKind.JSDocCallbackTag] = 'JSDocCallbackTag',
-    _a[ts.SyntaxKind.JSDocEnumTag] = 'JSDocEnumTag',
-    _a[ts.SyntaxKind.JSDocParameterTag] = 'JSDocParameterTag',
-    _a[ts.SyntaxKind.JSDocReturnTag] = 'JSDocReturnTag',
-    _a[ts.SyntaxKind.JSDocThisTag] = 'JSDocThisTag',
-    _a[ts.SyntaxKind.JSDocTypeTag] = 'JSDocTypeTag',
-    _a[ts.SyntaxKind.JSDocTemplateTag] = 'JSDocTemplateTag',
-    _a[ts.SyntaxKind.JSDocTypedefTag] = 'JSDocTypedefTag',
-    _a[ts.SyntaxKind.JSDocSeeTag] = 'JSDocSeeTag',
-    _a[ts.SyntaxKind.JSDocPropertyTag] = 'JSDocPropertyTag',
-    _a[ts.SyntaxKind.SyntaxList] = 'SyntaxList',
-    _a[ts.SyntaxKind.NotEmittedStatement] = 'NotEmittedStatement',
-    _a[ts.SyntaxKind.PartiallyEmittedExpression] = 'PartiallyEmittedExpression',
-    _a[ts.SyntaxKind.CommaListExpression] = 'CommaListExpression',
-    _a);
+const kindToString = {
+    [ts.SyntaxKind.NumericLiteral]: 'NumericLiteral',
+    [ts.SyntaxKind.BigIntLiteral]: 'BigIntLiteral',
+    [ts.SyntaxKind.StringLiteral]: 'StringLiteral',
+    [ts.SyntaxKind.JsxText]: 'JsxText',
+    [ts.SyntaxKind.RegularExpressionLiteral]: 'RegularExpressionLiteral',
+    [ts.SyntaxKind.NoSubstitutionTemplateLiteral]: 'NoSubstitutionTemplateLiteral',
+    [ts.SyntaxKind.TemplateHead]: 'TemplateHead',
+    [ts.SyntaxKind.TemplateMiddle]: 'TemplateMiddle',
+    [ts.SyntaxKind.TemplateTail]: 'TemplateTail',
+    [ts.SyntaxKind.Identifier]: 'Identifier',
+    [ts.SyntaxKind.PrivateIdentifier]: 'PrivateIdentifier',
+    [ts.SyntaxKind.FalseKeyword]: 'FalseKeyword',
+    [ts.SyntaxKind.ImportKeyword]: 'ImportKeyword',
+    [ts.SyntaxKind.NullKeyword]: 'NullKeyword',
+    [ts.SyntaxKind.SuperKeyword]: 'SuperKeyword',
+    [ts.SyntaxKind.ThisKeyword]: 'ThisKeyword',
+    [ts.SyntaxKind.TrueKeyword]: 'TrueKeyword',
+    [ts.SyntaxKind.QualifiedName]: 'QualifiedName',
+    [ts.SyntaxKind.ComputedPropertyName]: 'ComputedPropertyName',
+    [ts.SyntaxKind.TypeParameter]: 'TypeParameter',
+    [ts.SyntaxKind.Parameter]: 'Parameter',
+    [ts.SyntaxKind.Decorator]: 'Decorator',
+    [ts.SyntaxKind.PropertySignature]: 'PropertySignature',
+    [ts.SyntaxKind.PropertyDeclaration]: 'PropertyDeclaration',
+    [ts.SyntaxKind.MethodSignature]: 'MethodSignature',
+    [ts.SyntaxKind.MethodDeclaration]: 'MethodDeclaration',
+    [ts.SyntaxKind.Constructor]: 'Constructor',
+    [ts.SyntaxKind.GetAccessor]: 'GetAccessor',
+    [ts.SyntaxKind.SetAccessor]: 'SetAccessor',
+    [ts.SyntaxKind.CallSignature]: 'CallSignature',
+    [ts.SyntaxKind.ConstructSignature]: 'ConstructSignature',
+    [ts.SyntaxKind.IndexSignature]: 'IndexSignature',
+    [ts.SyntaxKind.TypePredicate]: 'TypePredicate',
+    [ts.SyntaxKind.TypeReference]: 'TypeReference',
+    [ts.SyntaxKind.FunctionType]: 'FunctionType',
+    [ts.SyntaxKind.ConstructorType]: 'ConstructorType',
+    [ts.SyntaxKind.TypeQuery]: 'TypeQuery',
+    [ts.SyntaxKind.TypeLiteral]: 'TypeLiteral',
+    [ts.SyntaxKind.ArrayType]: 'ArrayType',
+    [ts.SyntaxKind.TupleType]: 'TupleType',
+    [ts.SyntaxKind.OptionalType]: 'OptionalType',
+    [ts.SyntaxKind.RestType]: 'RestType',
+    [ts.SyntaxKind.UnionType]: 'UnionType',
+    [ts.SyntaxKind.IntersectionType]: 'IntersectionType',
+    [ts.SyntaxKind.ConditionalType]: 'ConditionalType',
+    [ts.SyntaxKind.InferType]: 'InferType',
+    [ts.SyntaxKind.ParenthesizedType]: 'ParenthesizedType',
+    [ts.SyntaxKind.ThisType]: 'ThisType',
+    [ts.SyntaxKind.TypeOperator]: 'TypeOperator',
+    [ts.SyntaxKind.IndexedAccessType]: 'IndexedAccessType',
+    [ts.SyntaxKind.MappedType]: 'MappedType',
+    [ts.SyntaxKind.LiteralType]: 'LiteralType',
+    [ts.SyntaxKind.NamedTupleMember]: 'NamedTupleMember',
+    [ts.SyntaxKind.TemplateLiteralType]: 'TemplateLiteralType',
+    [ts.SyntaxKind.TemplateLiteralTypeSpan]: 'TemplateLiteralTypeSpan',
+    [ts.SyntaxKind.ImportType]: 'ImportType',
+    [ts.SyntaxKind.ObjectBindingPattern]: 'ObjectBindingPattern',
+    [ts.SyntaxKind.ArrayBindingPattern]: 'ArrayBindingPattern',
+    [ts.SyntaxKind.BindingElement]: 'BindingElement',
+    [ts.SyntaxKind.ArrayLiteralExpression]: 'ArrayLiteralExpression',
+    [ts.SyntaxKind.ObjectLiteralExpression]: 'ObjectLiteralExpression',
+    [ts.SyntaxKind.PropertyAccessExpression]: 'PropertyAccessExpression',
+    [ts.SyntaxKind.ElementAccessExpression]: 'ElementAccessExpression',
+    [ts.SyntaxKind.CallExpression]: 'CallExpression',
+    [ts.SyntaxKind.NewExpression]: 'NewExpression',
+    [ts.SyntaxKind.TaggedTemplateExpression]: 'TaggedTemplateExpression',
+    [ts.SyntaxKind.TypeAssertionExpression]: 'TypeAssertionExpression',
+    [ts.SyntaxKind.ParenthesizedExpression]: 'ParenthesizedExpression',
+    [ts.SyntaxKind.FunctionExpression]: 'FunctionExpression',
+    [ts.SyntaxKind.ArrowFunction]: 'ArrowFunction',
+    [ts.SyntaxKind.DeleteExpression]: 'DeleteExpression',
+    [ts.SyntaxKind.TypeOfExpression]: 'TypeOfExpression',
+    [ts.SyntaxKind.VoidExpression]: 'VoidExpression',
+    [ts.SyntaxKind.AwaitExpression]: 'AwaitExpression',
+    [ts.SyntaxKind.PrefixUnaryExpression]: 'PrefixUnaryExpression',
+    [ts.SyntaxKind.PostfixUnaryExpression]: 'PostfixUnaryExpression',
+    [ts.SyntaxKind.BinaryExpression]: 'BinaryExpression',
+    [ts.SyntaxKind.ConditionalExpression]: 'ConditionalExpression',
+    [ts.SyntaxKind.TemplateExpression]: 'TemplateExpression',
+    [ts.SyntaxKind.YieldExpression]: 'YieldExpression',
+    [ts.SyntaxKind.SpreadElement]: 'SpreadElement',
+    [ts.SyntaxKind.ClassExpression]: 'ClassExpression',
+    [ts.SyntaxKind.OmittedExpression]: 'OmittedExpression',
+    [ts.SyntaxKind.ExpressionWithTypeArguments]: 'ExpressionWithTypeArguments',
+    [ts.SyntaxKind.AsExpression]: 'AsExpression',
+    [ts.SyntaxKind.NonNullExpression]: 'NonNullExpression',
+    [ts.SyntaxKind.MetaProperty]: 'MetaProperty',
+    [ts.SyntaxKind.SyntheticExpression]: 'SyntheticExpression',
+    [ts.SyntaxKind.TemplateSpan]: 'TemplateSpan',
+    [ts.SyntaxKind.SemicolonClassElement]: 'SemicolonClassElement',
+    [ts.SyntaxKind.Block]: 'Block',
+    [ts.SyntaxKind.EmptyStatement]: 'EmptyStatement',
+    [ts.SyntaxKind.VariableStatement]: 'VariableStatement',
+    [ts.SyntaxKind.ExpressionStatement]: 'ExpressionStatement',
+    [ts.SyntaxKind.IfStatement]: 'IfStatement',
+    [ts.SyntaxKind.DoStatement]: 'DoStatement',
+    [ts.SyntaxKind.WhileStatement]: 'WhileStatement',
+    [ts.SyntaxKind.ForStatement]: 'ForStatement',
+    [ts.SyntaxKind.ForInStatement]: 'ForInStatement',
+    [ts.SyntaxKind.ForOfStatement]: 'ForOfStatement',
+    [ts.SyntaxKind.ContinueStatement]: 'ContinueStatement',
+    [ts.SyntaxKind.BreakStatement]: 'BreakStatement',
+    [ts.SyntaxKind.ReturnStatement]: 'ReturnStatement',
+    [ts.SyntaxKind.WithStatement]: 'WithStatement',
+    [ts.SyntaxKind.SwitchStatement]: 'SwitchStatement',
+    [ts.SyntaxKind.LabeledStatement]: 'LabeledStatement',
+    [ts.SyntaxKind.ThrowStatement]: 'ThrowStatement',
+    [ts.SyntaxKind.TryStatement]: 'TryStatement',
+    [ts.SyntaxKind.DebuggerStatement]: 'DebuggerStatement',
+    [ts.SyntaxKind.VariableDeclaration]: 'VariableDeclaration',
+    [ts.SyntaxKind.VariableDeclarationList]: 'VariableDeclarationList',
+    [ts.SyntaxKind.FunctionDeclaration]: 'FunctionDeclaration',
+    [ts.SyntaxKind.ClassDeclaration]: 'ClassDeclaration',
+    [ts.SyntaxKind.InterfaceDeclaration]: 'InterfaceDeclaration',
+    [ts.SyntaxKind.TypeAliasDeclaration]: 'TypeAliasDeclaration',
+    [ts.SyntaxKind.EnumDeclaration]: 'EnumDeclaration',
+    [ts.SyntaxKind.ModuleDeclaration]: 'ModuleDeclaration',
+    [ts.SyntaxKind.ModuleBlock]: 'ModuleBlock',
+    [ts.SyntaxKind.CaseBlock]: 'CaseBlock',
+    [ts.SyntaxKind.NamespaceExportDeclaration]: 'NamespaceExportDeclaration',
+    [ts.SyntaxKind.ImportEqualsDeclaration]: 'ImportEqualsDeclaration',
+    [ts.SyntaxKind.ImportDeclaration]: 'ImportDeclaration',
+    [ts.SyntaxKind.ImportClause]: 'ImportClause',
+    [ts.SyntaxKind.NamespaceImport]: 'NamespaceImport',
+    [ts.SyntaxKind.NamedImports]: 'NamedImports',
+    [ts.SyntaxKind.ImportSpecifier]: 'ImportSpecifier',
+    [ts.SyntaxKind.ExportAssignment]: 'ExportAssignment',
+    [ts.SyntaxKind.ExportDeclaration]: 'ExportDeclaration',
+    [ts.SyntaxKind.NamedExports]: 'NamedExports',
+    [ts.SyntaxKind.NamespaceExport]: 'NamespaceExport',
+    [ts.SyntaxKind.ExportSpecifier]: 'ExportSpecifier',
+    [ts.SyntaxKind.MissingDeclaration]: 'MissingDeclaration',
+    [ts.SyntaxKind.ExternalModuleReference]: 'ExternalModuleReference',
+    [ts.SyntaxKind.JsxElement]: 'JsxElement',
+    [ts.SyntaxKind.JsxSelfClosingElement]: 'JsxSelfClosingElement',
+    [ts.SyntaxKind.JsxOpeningElement]: 'JsxOpeningElement',
+    [ts.SyntaxKind.JsxClosingElement]: 'JsxClosingElement',
+    [ts.SyntaxKind.JsxFragment]: 'JsxFragment',
+    [ts.SyntaxKind.JsxOpeningFragment]: 'JsxOpeningFragment',
+    [ts.SyntaxKind.JsxClosingFragment]: 'JsxClosingFragment',
+    [ts.SyntaxKind.JsxAttribute]: 'JsxAttribute',
+    [ts.SyntaxKind.JsxAttributes]: 'JsxAttributes',
+    [ts.SyntaxKind.JsxSpreadAttribute]: 'JsxSpreadAttribute',
+    [ts.SyntaxKind.JsxExpression]: 'JsxExpression',
+    [ts.SyntaxKind.CaseClause]: 'CaseClause',
+    [ts.SyntaxKind.DefaultClause]: 'DefaultClause',
+    [ts.SyntaxKind.HeritageClause]: 'HeritageClause',
+    [ts.SyntaxKind.CatchClause]: 'CatchClause',
+    [ts.SyntaxKind.PropertyAssignment]: 'PropertyAssignment',
+    [ts.SyntaxKind.ShorthandPropertyAssignment]: 'ShorthandPropertyAssignment',
+    [ts.SyntaxKind.SpreadAssignment]: 'SpreadAssignment',
+    [ts.SyntaxKind.EnumMember]: 'EnumMember',
+    [ts.SyntaxKind.UnparsedPrologue]: 'UnparsedPrologue',
+    [ts.SyntaxKind.UnparsedPrepend]: 'UnparsedPrepend',
+    [ts.SyntaxKind.UnparsedSyntheticReference]: 'UnparsedSyntheticReference',
+    [ts.SyntaxKind.SourceFile]: 'SourceFile',
+    [ts.SyntaxKind.Bundle]: 'Bundle',
+    [ts.SyntaxKind.UnparsedSource]: 'UnparsedSource',
+    [ts.SyntaxKind.InputFiles]: 'InputFiles',
+    [ts.SyntaxKind.JSDocTypeExpression]: 'JSDocTypeExpression',
+    [ts.SyntaxKind.JSDocNameReference]: 'JSDocNameReference',
+    [ts.SyntaxKind.JSDocAllType]: 'JSDocAllType',
+    [ts.SyntaxKind.JSDocUnknownType]: 'JSDocUnknownType',
+    [ts.SyntaxKind.JSDocNullableType]: 'JSDocNullableType',
+    [ts.SyntaxKind.JSDocNonNullableType]: 'JSDocNonNullableType',
+    [ts.SyntaxKind.JSDocOptionalType]: 'JSDocOptionalType',
+    [ts.SyntaxKind.JSDocFunctionType]: 'JSDocFunctionType',
+    [ts.SyntaxKind.JSDocVariadicType]: 'JSDocVariadicType',
+    [ts.SyntaxKind.JSDocNamepathType]: 'JSDocNamepathType',
+    [ts.SyntaxKind.JSDocComment]: 'JSDocComment',
+    [ts.SyntaxKind.JSDocTypeLiteral]: 'JSDocTypeLiteral',
+    [ts.SyntaxKind.JSDocSignature]: 'JSDocSignature',
+    [ts.SyntaxKind.JSDocTag]: 'JSDocTag',
+    [ts.SyntaxKind.JSDocAugmentsTag]: 'JSDocAugmentsTag',
+    [ts.SyntaxKind.JSDocImplementsTag]: 'JSDocImplementsTag',
+    [ts.SyntaxKind.JSDocAuthorTag]: 'JSDocAuthorTag',
+    [ts.SyntaxKind.JSDocDeprecatedTag]: 'JSDocDeprecatedTag',
+    [ts.SyntaxKind.JSDocClassTag]: 'JSDocClassTag',
+    [ts.SyntaxKind.JSDocPublicTag]: 'JSDocPublicTag',
+    [ts.SyntaxKind.JSDocPrivateTag]: 'JSDocPrivateTag',
+    [ts.SyntaxKind.JSDocProtectedTag]: 'JSDocProtectedTag',
+    [ts.SyntaxKind.JSDocReadonlyTag]: 'JSDocReadonlyTag',
+    [ts.SyntaxKind.JSDocCallbackTag]: 'JSDocCallbackTag',
+    [ts.SyntaxKind.JSDocEnumTag]: 'JSDocEnumTag',
+    [ts.SyntaxKind.JSDocParameterTag]: 'JSDocParameterTag',
+    [ts.SyntaxKind.JSDocReturnTag]: 'JSDocReturnTag',
+    [ts.SyntaxKind.JSDocThisTag]: 'JSDocThisTag',
+    [ts.SyntaxKind.JSDocTypeTag]: 'JSDocTypeTag',
+    [ts.SyntaxKind.JSDocTemplateTag]: 'JSDocTemplateTag',
+    [ts.SyntaxKind.JSDocTypedefTag]: 'JSDocTypedefTag',
+    [ts.SyntaxKind.JSDocSeeTag]: 'JSDocSeeTag',
+    [ts.SyntaxKind.JSDocPropertyTag]: 'JSDocPropertyTag',
+    [ts.SyntaxKind.SyntaxList]: 'SyntaxList',
+    [ts.SyntaxKind.NotEmittedStatement]: 'NotEmittedStatement',
+    [ts.SyntaxKind.PartiallyEmittedExpression]: 'PartiallyEmittedExpression',
+    [ts.SyntaxKind.CommaListExpression]: 'CommaListExpression',
+};
 export function getKindNameFromNode(node) {
     // @ts-ignore
     return kindToString[node.kind] || String(node.kind);