@nubjs/nub-linux-x64 0.0.7 → 0.0.8

package/runtime/node_modules/oxc-parser/src-js/generated/visit/walk.js

@@ -0,0 +1,2455 @@
+// Auto-generated code, DO NOT EDIT DIRECTLY!
+// To edit this generated file you have to edit `tasks/ast_tools/src/generators/estree_visit.rs`.
+
+export { walkProgram };
+
+function walkNode(node, visitors) {
+  if (node == null) return;
+  if (Array.isArray(node)) {
+    let len = node.length;
+    for (let i = 0; i < len; i++) walkNode(node[i], visitors);
+  } else
+    switch (node.type) {
+      case "DebuggerStatement":
+        walkDebuggerStatement(node, visitors);
+        break;
+      case "EmptyStatement":
+        walkEmptyStatement(node, visitors);
+        break;
+      case "Literal":
+        walkLiteral(node, visitors);
+        break;
+      case "PrivateIdentifier":
+        walkPrivateIdentifier(node, visitors);
+        break;
+      case "Super":
+        walkSuper(node, visitors);
+        break;
+      case "TemplateElement":
+        walkTemplateElement(node, visitors);
+        break;
+      case "ThisExpression":
+        walkThisExpression(node, visitors);
+        break;
+      case "JSXClosingFragment":
+        walkJSXClosingFragment(node, visitors);
+        break;
+      case "JSXEmptyExpression":
+        walkJSXEmptyExpression(node, visitors);
+        break;
+      case "JSXIdentifier":
+        walkJSXIdentifier(node, visitors);
+        break;
+      case "JSXOpeningFragment":
+        walkJSXOpeningFragment(node, visitors);
+        break;
+      case "JSXText":
+        walkJSXText(node, visitors);
+        break;
+      case "TSAnyKeyword":
+        walkTSAnyKeyword(node, visitors);
+        break;
+      case "TSBigIntKeyword":
+        walkTSBigIntKeyword(node, visitors);
+        break;
+      case "TSBooleanKeyword":
+        walkTSBooleanKeyword(node, visitors);
+        break;
+      case "TSIntrinsicKeyword":
+        walkTSIntrinsicKeyword(node, visitors);
+        break;
+      case "TSJSDocUnknownType":
+        walkTSJSDocUnknownType(node, visitors);
+        break;
+      case "TSNeverKeyword":
+        walkTSNeverKeyword(node, visitors);
+        break;
+      case "TSNullKeyword":
+        walkTSNullKeyword(node, visitors);
+        break;
+      case "TSNumberKeyword":
+        walkTSNumberKeyword(node, visitors);
+        break;
+      case "TSObjectKeyword":
+        walkTSObjectKeyword(node, visitors);
+        break;
+      case "TSStringKeyword":
+        walkTSStringKeyword(node, visitors);
+        break;
+      case "TSSymbolKeyword":
+        walkTSSymbolKeyword(node, visitors);
+        break;
+      case "TSThisType":
+        walkTSThisType(node, visitors);
+        break;
+      case "TSUndefinedKeyword":
+        walkTSUndefinedKeyword(node, visitors);
+        break;
+      case "TSUnknownKeyword":
+        walkTSUnknownKeyword(node, visitors);
+        break;
+      case "TSVoidKeyword":
+        walkTSVoidKeyword(node, visitors);
+        break;
+      case "AccessorProperty":
+        walkAccessorProperty(node, visitors);
+        break;
+      case "ArrayExpression":
+        walkArrayExpression(node, visitors);
+        break;
+      case "ArrayPattern":
+        walkArrayPattern(node, visitors);
+        break;
+      case "ArrowFunctionExpression":
+        walkArrowFunctionExpression(node, visitors);
+        break;
+      case "AssignmentExpression":
+        walkAssignmentExpression(node, visitors);
+        break;
+      case "AssignmentPattern":
+        walkAssignmentPattern(node, visitors);
+        break;
+      case "AwaitExpression":
+        walkAwaitExpression(node, visitors);
+        break;
+      case "BinaryExpression":
+        walkBinaryExpression(node, visitors);
+        break;
+      case "BlockStatement":
+        walkBlockStatement(node, visitors);
+        break;
+      case "BreakStatement":
+        walkBreakStatement(node, visitors);
+        break;
+      case "CallExpression":
+        walkCallExpression(node, visitors);
+        break;
+      case "CatchClause":
+        walkCatchClause(node, visitors);
+        break;
+      case "ChainExpression":
+        walkChainExpression(node, visitors);
+        break;
+      case "ClassBody":
+        walkClassBody(node, visitors);
+        break;
+      case "ClassDeclaration":
+        walkClassDeclaration(node, visitors);
+        break;
+      case "ClassExpression":
+        walkClassExpression(node, visitors);
+        break;
+      case "ConditionalExpression":
+        walkConditionalExpression(node, visitors);
+        break;
+      case "ContinueStatement":
+        walkContinueStatement(node, visitors);
+        break;
+      case "Decorator":
+        walkDecorator(node, visitors);
+        break;
+      case "DoWhileStatement":
+        walkDoWhileStatement(node, visitors);
+        break;
+      case "ExportAllDeclaration":
+        walkExportAllDeclaration(node, visitors);
+        break;
+      case "ExportDefaultDeclaration":
+        walkExportDefaultDeclaration(node, visitors);
+        break;
+      case "ExportNamedDeclaration":
+        walkExportNamedDeclaration(node, visitors);
+        break;
+      case "ExportSpecifier":
+        walkExportSpecifier(node, visitors);
+        break;
+      case "ExpressionStatement":
+        walkExpressionStatement(node, visitors);
+        break;
+      case "ForInStatement":
+        walkForInStatement(node, visitors);
+        break;
+      case "ForOfStatement":
+        walkForOfStatement(node, visitors);
+        break;
+      case "ForStatement":
+        walkForStatement(node, visitors);
+        break;
+      case "FunctionDeclaration":
+        walkFunctionDeclaration(node, visitors);
+        break;
+      case "FunctionExpression":
+        walkFunctionExpression(node, visitors);
+        break;
+      case "Identifier":
+        walkIdentifier(node, visitors);
+        break;
+      case "IfStatement":
+        walkIfStatement(node, visitors);
+        break;
+      case "ImportAttribute":
+        walkImportAttribute(node, visitors);
+        break;
+      case "ImportDeclaration":
+        walkImportDeclaration(node, visitors);
+        break;
+      case "ImportDefaultSpecifier":
+        walkImportDefaultSpecifier(node, visitors);
+        break;
+      case "ImportExpression":
+        walkImportExpression(node, visitors);
+        break;
+      case "ImportNamespaceSpecifier":
+        walkImportNamespaceSpecifier(node, visitors);
+        break;
+      case "ImportSpecifier":
+        walkImportSpecifier(node, visitors);
+        break;
+      case "LabeledStatement":
+        walkLabeledStatement(node, visitors);
+        break;
+      case "LogicalExpression":
+        walkLogicalExpression(node, visitors);
+        break;
+      case "MemberExpression":
+        walkMemberExpression(node, visitors);
+        break;
+      case "MetaProperty":
+        walkMetaProperty(node, visitors);
+        break;
+      case "MethodDefinition":
+        walkMethodDefinition(node, visitors);
+        break;
+      case "NewExpression":
+        walkNewExpression(node, visitors);
+        break;
+      case "ObjectExpression":
+        walkObjectExpression(node, visitors);
+        break;
+      case "ObjectPattern":
+        walkObjectPattern(node, visitors);
+        break;
+      case "ParenthesizedExpression":
+        walkParenthesizedExpression(node, visitors);
+        break;
+      case "Program":
+        walkProgram(node, visitors);
+        break;
+      case "Property":
+        walkProperty(node, visitors);
+        break;
+      case "PropertyDefinition":
+        walkPropertyDefinition(node, visitors);
+        break;
+      case "RestElement":
+        walkRestElement(node, visitors);
+        break;
+      case "ReturnStatement":
+        walkReturnStatement(node, visitors);
+        break;
+      case "SequenceExpression":
+        walkSequenceExpression(node, visitors);
+        break;
+      case "SpreadElement":
+        walkSpreadElement(node, visitors);
+        break;
+      case "StaticBlock":
+        walkStaticBlock(node, visitors);
+        break;
+      case "SwitchCase":
+        walkSwitchCase(node, visitors);
+        break;
+      case "SwitchStatement":
+        walkSwitchStatement(node, visitors);
+        break;
+      case "TaggedTemplateExpression":
+        walkTaggedTemplateExpression(node, visitors);
+        break;
+      case "TemplateLiteral":
+        walkTemplateLiteral(node, visitors);
+        break;
+      case "ThrowStatement":
+        walkThrowStatement(node, visitors);
+        break;
+      case "TryStatement":
+        walkTryStatement(node, visitors);
+        break;
+      case "UnaryExpression":
+        walkUnaryExpression(node, visitors);
+        break;
+      case "UpdateExpression":
+        walkUpdateExpression(node, visitors);
+        break;
+      case "V8IntrinsicExpression":
+        walkV8IntrinsicExpression(node, visitors);
+        break;
+      case "VariableDeclaration":
+        walkVariableDeclaration(node, visitors);
+        break;
+      case "VariableDeclarator":
+        walkVariableDeclarator(node, visitors);
+        break;
+      case "WhileStatement":
+        walkWhileStatement(node, visitors);
+        break;
+      case "WithStatement":
+        walkWithStatement(node, visitors);
+        break;
+      case "YieldExpression":
+        walkYieldExpression(node, visitors);
+        break;
+      case "JSXAttribute":
+        walkJSXAttribute(node, visitors);
+        break;
+      case "JSXClosingElement":
+        walkJSXClosingElement(node, visitors);
+        break;
+      case "JSXElement":
+        walkJSXElement(node, visitors);
+        break;
+      case "JSXExpressionContainer":
+        walkJSXExpressionContainer(node, visitors);
+        break;
+      case "JSXFragment":
+        walkJSXFragment(node, visitors);
+        break;
+      case "JSXMemberExpression":
+        walkJSXMemberExpression(node, visitors);
+        break;
+      case "JSXNamespacedName":
+        walkJSXNamespacedName(node, visitors);
+        break;
+      case "JSXOpeningElement":
+        walkJSXOpeningElement(node, visitors);
+        break;
+      case "JSXSpreadAttribute":
+        walkJSXSpreadAttribute(node, visitors);
+        break;
+      case "JSXSpreadChild":
+        walkJSXSpreadChild(node, visitors);
+        break;
+      case "TSAbstractAccessorProperty":
+        walkTSAbstractAccessorProperty(node, visitors);
+        break;
+      case "TSAbstractMethodDefinition":
+        walkTSAbstractMethodDefinition(node, visitors);
+        break;
+      case "TSAbstractPropertyDefinition":
+        walkTSAbstractPropertyDefinition(node, visitors);
+        break;
+      case "TSArrayType":
+        walkTSArrayType(node, visitors);
+        break;
+      case "TSAsExpression":
+        walkTSAsExpression(node, visitors);
+        break;
+      case "TSCallSignatureDeclaration":
+        walkTSCallSignatureDeclaration(node, visitors);
+        break;
+      case "TSClassImplements":
+        walkTSClassImplements(node, visitors);
+        break;
+      case "TSConditionalType":
+        walkTSConditionalType(node, visitors);
+        break;
+      case "TSConstructSignatureDeclaration":
+        walkTSConstructSignatureDeclaration(node, visitors);
+        break;
+      case "TSConstructorType":
+        walkTSConstructorType(node, visitors);
+        break;
+      case "TSDeclareFunction":
+        walkTSDeclareFunction(node, visitors);
+        break;
+      case "TSEmptyBodyFunctionExpression":
+        walkTSEmptyBodyFunctionExpression(node, visitors);
+        break;
+      case "TSEnumBody":
+        walkTSEnumBody(node, visitors);
+        break;
+      case "TSEnumDeclaration":
+        walkTSEnumDeclaration(node, visitors);
+        break;
+      case "TSEnumMember":
+        walkTSEnumMember(node, visitors);
+        break;
+      case "TSExportAssignment":
+        walkTSExportAssignment(node, visitors);
+        break;
+      case "TSExternalModuleReference":
+        walkTSExternalModuleReference(node, visitors);
+        break;
+      case "TSFunctionType":
+        walkTSFunctionType(node, visitors);
+        break;
+      case "TSImportEqualsDeclaration":
+        walkTSImportEqualsDeclaration(node, visitors);
+        break;
+      case "TSImportType":
+        walkTSImportType(node, visitors);
+        break;
+      case "TSIndexSignature":
+        walkTSIndexSignature(node, visitors);
+        break;
+      case "TSIndexedAccessType":
+        walkTSIndexedAccessType(node, visitors);
+        break;
+      case "TSInferType":
+        walkTSInferType(node, visitors);
+        break;
+      case "TSInstantiationExpression":
+        walkTSInstantiationExpression(node, visitors);
+        break;
+      case "TSInterfaceBody":
+        walkTSInterfaceBody(node, visitors);
+        break;
+      case "TSInterfaceDeclaration":
+        walkTSInterfaceDeclaration(node, visitors);
+        break;
+      case "TSInterfaceHeritage":
+        walkTSInterfaceHeritage(node, visitors);
+        break;
+      case "TSIntersectionType":
+        walkTSIntersectionType(node, visitors);
+        break;
+      case "TSJSDocNonNullableType":
+        walkTSJSDocNonNullableType(node, visitors);
+        break;
+      case "TSJSDocNullableType":
+        walkTSJSDocNullableType(node, visitors);
+        break;
+      case "TSLiteralType":
+        walkTSLiteralType(node, visitors);
+        break;
+      case "TSMappedType":
+        walkTSMappedType(node, visitors);
+        break;
+      case "TSMethodSignature":
+        walkTSMethodSignature(node, visitors);
+        break;
+      case "TSModuleBlock":
+        walkTSModuleBlock(node, visitors);
+        break;
+      case "TSModuleDeclaration":
+        walkTSModuleDeclaration(node, visitors);
+        break;
+      case "TSNamedTupleMember":
+        walkTSNamedTupleMember(node, visitors);
+        break;
+      case "TSNamespaceExportDeclaration":
+        walkTSNamespaceExportDeclaration(node, visitors);
+        break;
+      case "TSNonNullExpression":
+        walkTSNonNullExpression(node, visitors);
+        break;
+      case "TSOptionalType":
+        walkTSOptionalType(node, visitors);
+        break;
+      case "TSParameterProperty":
+        walkTSParameterProperty(node, visitors);
+        break;
+      case "TSParenthesizedType":
+        walkTSParenthesizedType(node, visitors);
+        break;
+      case "TSPropertySignature":
+        walkTSPropertySignature(node, visitors);
+        break;
+      case "TSQualifiedName":
+        walkTSQualifiedName(node, visitors);
+        break;
+      case "TSRestType":
+        walkTSRestType(node, visitors);
+        break;
+      case "TSSatisfiesExpression":
+        walkTSSatisfiesExpression(node, visitors);
+        break;
+      case "TSTemplateLiteralType":
+        walkTSTemplateLiteralType(node, visitors);
+        break;
+      case "TSTupleType":
+        walkTSTupleType(node, visitors);
+        break;
+      case "TSTypeAliasDeclaration":
+        walkTSTypeAliasDeclaration(node, visitors);
+        break;
+      case "TSTypeAnnotation":
+        walkTSTypeAnnotation(node, visitors);
+        break;
+      case "TSTypeAssertion":
+        walkTSTypeAssertion(node, visitors);
+        break;
+      case "TSTypeLiteral":
+        walkTSTypeLiteral(node, visitors);
+        break;
+      case "TSTypeOperator":
+        walkTSTypeOperator(node, visitors);
+        break;
+      case "TSTypeParameter":
+        walkTSTypeParameter(node, visitors);
+        break;
+      case "TSTypeParameterDeclaration":
+        walkTSTypeParameterDeclaration(node, visitors);
+        break;
+      case "TSTypeParameterInstantiation":
+        walkTSTypeParameterInstantiation(node, visitors);
+        break;
+      case "TSTypePredicate":
+        walkTSTypePredicate(node, visitors);
+        break;
+      case "TSTypeQuery":
+        walkTSTypeQuery(node, visitors);
+        break;
+      case "TSTypeReference":
+        walkTSTypeReference(node, visitors);
+        break;
+      case "TSUnionType":
+        walkTSUnionType(node, visitors);
+        break;
+    }
+}
+
+function walkDebuggerStatement(node, visitors) {
+  let visit = visitors[0];
+  visit !== null && visit(node);
+}
+
+function walkEmptyStatement(node, visitors) {
+  let visit = visitors[1];
+  visit !== null && visit(node);
+}
+
+function walkLiteral(node, visitors) {
+  let visit = visitors[2];
+  visit !== null && visit(node);
+}
+
+function walkPrivateIdentifier(node, visitors) {
+  let visit = visitors[3];
+  visit !== null && visit(node);
+}
+
+function walkSuper(node, visitors) {
+  let visit = visitors[4];
+  visit !== null && visit(node);
+}
+
+function walkTemplateElement(node, visitors) {
+  let visit = visitors[5];
+  visit !== null && visit(node);
+}
+
+function walkThisExpression(node, visitors) {
+  let visit = visitors[6];
+  visit !== null && visit(node);
+}
+
+function walkJSXClosingFragment(node, visitors) {
+  let visit = visitors[7];
+  visit !== null && visit(node);
+}
+
+function walkJSXEmptyExpression(node, visitors) {
+  let visit = visitors[8];
+  visit !== null && visit(node);
+}
+
+function walkJSXIdentifier(node, visitors) {
+  let visit = visitors[9];
+  visit !== null && visit(node);
+}
+
+function walkJSXOpeningFragment(node, visitors) {
+  let visit = visitors[10];
+  visit !== null && visit(node);
+}
+
+function walkJSXText(node, visitors) {
+  let visit = visitors[11];
+  visit !== null && visit(node);
+}
+
+function walkTSAnyKeyword(node, visitors) {
+  let visit = visitors[12];
+  visit !== null && visit(node);
+}
+
+function walkTSBigIntKeyword(node, visitors) {
+  let visit = visitors[13];
+  visit !== null && visit(node);
+}
+
+function walkTSBooleanKeyword(node, visitors) {
+  let visit = visitors[14];
+  visit !== null && visit(node);
+}
+
+function walkTSIntrinsicKeyword(node, visitors) {
+  let visit = visitors[15];
+  visit !== null && visit(node);
+}
+
+function walkTSJSDocUnknownType(node, visitors) {
+  let visit = visitors[16];
+  visit !== null && visit(node);
+}
+
+function walkTSNeverKeyword(node, visitors) {
+  let visit = visitors[17];
+  visit !== null && visit(node);
+}
+
+function walkTSNullKeyword(node, visitors) {
+  let visit = visitors[18];
+  visit !== null && visit(node);
+}
+
+function walkTSNumberKeyword(node, visitors) {
+  let visit = visitors[19];
+  visit !== null && visit(node);
+}
+
+function walkTSObjectKeyword(node, visitors) {
+  let visit = visitors[20];
+  visit !== null && visit(node);
+}
+
+function walkTSStringKeyword(node, visitors) {
+  let visit = visitors[21];
+  visit !== null && visit(node);
+}
+
+function walkTSSymbolKeyword(node, visitors) {
+  let visit = visitors[22];
+  visit !== null && visit(node);
+}
+
+function walkTSThisType(node, visitors) {
+  let visit = visitors[23];
+  visit !== null && visit(node);
+}
+
+function walkTSUndefinedKeyword(node, visitors) {
+  let visit = visitors[24];
+  visit !== null && visit(node);
+}
+
+function walkTSUnknownKeyword(node, visitors) {
+  let visit = visitors[25];
+  visit !== null && visit(node);
+}
+
+function walkTSVoidKeyword(node, visitors) {
+  let visit = visitors[26];
+  visit !== null && visit(node);
+}
+
+function walkAccessorProperty(node, visitors) {
+  let enterExit = visitors[27],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.decorators, visitors);
+  walkNode(node.key, visitors);
+  walkNode(node.typeAnnotation, visitors);
+  walkNode(node.value, visitors);
+  exit !== null && exit(node);
+}
+
+function walkArrayExpression(node, visitors) {
+  let enterExit = visitors[28],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.elements, visitors);
+  exit !== null && exit(node);
+}
+
+function walkArrayPattern(node, visitors) {
+  let enterExit = visitors[29],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.decorators, visitors);
+  walkNode(node.elements, visitors);
+  walkNode(node.typeAnnotation, visitors);
+  exit !== null && exit(node);
+}
+
+function walkArrowFunctionExpression(node, visitors) {
+  let enterExit = visitors[30],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.typeParameters, visitors);
+  walkNode(node.params, visitors);
+  walkNode(node.returnType, visitors);
+  walkNode(node.body, visitors);
+  exit !== null && exit(node);
+}
+
+function walkAssignmentExpression(node, visitors) {
+  let enterExit = visitors[31],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.left, visitors);
+  walkNode(node.right, visitors);
+  exit !== null && exit(node);
+}
+
+function walkAssignmentPattern(node, visitors) {
+  let enterExit = visitors[32],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.decorators, visitors);
+  walkNode(node.left, visitors);
+  walkNode(node.right, visitors);
+  walkNode(node.typeAnnotation, visitors);
+  exit !== null && exit(node);
+}
+
+function walkAwaitExpression(node, visitors) {
+  let enterExit = visitors[33],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.argument, visitors);
+  exit !== null && exit(node);
+}
+
+function walkBinaryExpression(node, visitors) {
+  let enterExit = visitors[34],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.left, visitors);
+  walkNode(node.right, visitors);
+  exit !== null && exit(node);
+}
+
+function walkBlockStatement(node, visitors) {
+  let enterExit = visitors[35],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.body, visitors);
+  exit !== null && exit(node);
+}
+
+function walkBreakStatement(node, visitors) {
+  let enterExit = visitors[36],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.label, visitors);
+  exit !== null && exit(node);
+}
+
+function walkCallExpression(node, visitors) {
+  let enterExit = visitors[37],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.callee, visitors);
+  walkNode(node.typeArguments, visitors);
+  walkNode(node.arguments, visitors);
+  exit !== null && exit(node);
+}
+
+function walkCatchClause(node, visitors) {
+  let enterExit = visitors[38],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.param, visitors);
+  walkNode(node.body, visitors);
+  exit !== null && exit(node);
+}
+
+function walkChainExpression(node, visitors) {
+  let enterExit = visitors[39],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.expression, visitors);
+  exit !== null && exit(node);
+}
+
+function walkClassBody(node, visitors) {
+  let enterExit = visitors[40],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.body, visitors);
+  exit !== null && exit(node);
+}
+
+function walkClassDeclaration(node, visitors) {
+  let enterExit = visitors[41],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.decorators, visitors);
+  walkNode(node.id, visitors);
+  walkNode(node.typeParameters, visitors);
+  walkNode(node.superClass, visitors);
+  walkNode(node.superTypeArguments, visitors);
+  walkNode(node.implements, visitors);
+  walkNode(node.body, visitors);
+  exit !== null && exit(node);
+}
+
+function walkClassExpression(node, visitors) {
+  let enterExit = visitors[42],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.decorators, visitors);
+  walkNode(node.id, visitors);
+  walkNode(node.typeParameters, visitors);
+  walkNode(node.superClass, visitors);
+  walkNode(node.superTypeArguments, visitors);
+  walkNode(node.implements, visitors);
+  walkNode(node.body, visitors);
+  exit !== null && exit(node);
+}
+
+function walkConditionalExpression(node, visitors) {
+  let enterExit = visitors[43],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.test, visitors);
+  walkNode(node.consequent, visitors);
+  walkNode(node.alternate, visitors);
+  exit !== null && exit(node);
+}
+
+function walkContinueStatement(node, visitors) {
+  let enterExit = visitors[44],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.label, visitors);
+  exit !== null && exit(node);
+}
+
+function walkDecorator(node, visitors) {
+  let enterExit = visitors[45],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.expression, visitors);
+  exit !== null && exit(node);
+}
+
+function walkDoWhileStatement(node, visitors) {
+  let enterExit = visitors[46],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.body, visitors);
+  walkNode(node.test, visitors);
+  exit !== null && exit(node);
+}
+
+function walkExportAllDeclaration(node, visitors) {
+  let enterExit = visitors[47],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.exported, visitors);
+  walkNode(node.source, visitors);
+  walkNode(node.attributes, visitors);
+  exit !== null && exit(node);
+}
+
+function walkExportDefaultDeclaration(node, visitors) {
+  let enterExit = visitors[48],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.declaration, visitors);
+  exit !== null && exit(node);
+}
+
+function walkExportNamedDeclaration(node, visitors) {
+  let enterExit = visitors[49],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.declaration, visitors);
+  walkNode(node.specifiers, visitors);
+  walkNode(node.source, visitors);
+  walkNode(node.attributes, visitors);
+  exit !== null && exit(node);
+}
+
+function walkExportSpecifier(node, visitors) {
+  let enterExit = visitors[50],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.local, visitors);
+  walkNode(node.exported, visitors);
+  exit !== null && exit(node);
+}
+
+function walkExpressionStatement(node, visitors) {
+  let enterExit = visitors[51],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.expression, visitors);
+  exit !== null && exit(node);
+}
+
+function walkForInStatement(node, visitors) {
+  let enterExit = visitors[52],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.left, visitors);
+  walkNode(node.right, visitors);
+  walkNode(node.body, visitors);
+  exit !== null && exit(node);
+}
+
+function walkForOfStatement(node, visitors) {
+  let enterExit = visitors[53],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.left, visitors);
+  walkNode(node.right, visitors);
+  walkNode(node.body, visitors);
+  exit !== null && exit(node);
+}
+
+function walkForStatement(node, visitors) {
+  let enterExit = visitors[54],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.init, visitors);
+  walkNode(node.test, visitors);
+  walkNode(node.update, visitors);
+  walkNode(node.body, visitors);
+  exit !== null && exit(node);
+}
+
+function walkFunctionDeclaration(node, visitors) {
+  let enterExit = visitors[55],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.id, visitors);
+  walkNode(node.typeParameters, visitors);
+  walkNode(node.params, visitors);
+  walkNode(node.returnType, visitors);
+  walkNode(node.body, visitors);
+  exit !== null && exit(node);
+}
+
+function walkFunctionExpression(node, visitors) {
+  let enterExit = visitors[56],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.id, visitors);
+  walkNode(node.typeParameters, visitors);
+  walkNode(node.params, visitors);
+  walkNode(node.returnType, visitors);
+  walkNode(node.body, visitors);
+  exit !== null && exit(node);
+}
+
+function walkIdentifier(node, visitors) {
+  let enterExit = visitors[57],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.decorators, visitors);
+  walkNode(node.typeAnnotation, visitors);
+  exit !== null && exit(node);
+}
+
+function walkIfStatement(node, visitors) {
+  let enterExit = visitors[58],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.test, visitors);
+  walkNode(node.consequent, visitors);
+  walkNode(node.alternate, visitors);
+  exit !== null && exit(node);
+}
+
+function walkImportAttribute(node, visitors) {
+  let enterExit = visitors[59],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.key, visitors);
+  walkNode(node.value, visitors);
+  exit !== null && exit(node);
+}
+
+function walkImportDeclaration(node, visitors) {
+  let enterExit = visitors[60],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.specifiers, visitors);
+  walkNode(node.source, visitors);
+  walkNode(node.attributes, visitors);
+  exit !== null && exit(node);
+}
+
+function walkImportDefaultSpecifier(node, visitors) {
+  let enterExit = visitors[61],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.local, visitors);
+  exit !== null && exit(node);
+}
+
+function walkImportExpression(node, visitors) {
+  let enterExit = visitors[62],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.source, visitors);
+  walkNode(node.options, visitors);
+  exit !== null && exit(node);
+}
+
+function walkImportNamespaceSpecifier(node, visitors) {
+  let enterExit = visitors[63],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.local, visitors);
+  exit !== null && exit(node);
+}
+
+function walkImportSpecifier(node, visitors) {
+  let enterExit = visitors[64],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.imported, visitors);
+  walkNode(node.local, visitors);
+  exit !== null && exit(node);
+}
+
+function walkLabeledStatement(node, visitors) {
+  let enterExit = visitors[65],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.label, visitors);
+  walkNode(node.body, visitors);
+  exit !== null && exit(node);
+}
+
+function walkLogicalExpression(node, visitors) {
+  let enterExit = visitors[66],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.left, visitors);
+  walkNode(node.right, visitors);
+  exit !== null && exit(node);
+}
+
+function walkMemberExpression(node, visitors) {
+  let enterExit = visitors[67],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.object, visitors);
+  walkNode(node.property, visitors);
+  exit !== null && exit(node);
+}
+
+function walkMetaProperty(node, visitors) {
+  let enterExit = visitors[68],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.meta, visitors);
+  walkNode(node.property, visitors);
+  exit !== null && exit(node);
+}
+
+function walkMethodDefinition(node, visitors) {
+  let enterExit = visitors[69],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.decorators, visitors);
+  walkNode(node.key, visitors);
+  walkNode(node.value, visitors);
+  exit !== null && exit(node);
+}
+
+function walkNewExpression(node, visitors) {
+  let enterExit = visitors[70],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.callee, visitors);
+  walkNode(node.typeArguments, visitors);
+  walkNode(node.arguments, visitors);
+  exit !== null && exit(node);
+}
+
+function walkObjectExpression(node, visitors) {
+  let enterExit = visitors[71],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.properties, visitors);
+  exit !== null && exit(node);
+}
+
+function walkObjectPattern(node, visitors) {
+  let enterExit = visitors[72],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.decorators, visitors);
+  walkNode(node.properties, visitors);
+  walkNode(node.typeAnnotation, visitors);
+  exit !== null && exit(node);
+}
+
+function walkParenthesizedExpression(node, visitors) {
+  let enterExit = visitors[73],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.expression, visitors);
+  exit !== null && exit(node);
+}
+
+function walkProgram(node, visitors) {
+  let enterExit = visitors[74],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.body, visitors);
+  exit !== null && exit(node);
+}
+
+function walkProperty(node, visitors) {
+  let enterExit = visitors[75],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.key, visitors);
+  walkNode(node.value, visitors);
+  exit !== null && exit(node);
+}
+
+function walkPropertyDefinition(node, visitors) {
+  let enterExit = visitors[76],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.decorators, visitors);
+  walkNode(node.key, visitors);
+  walkNode(node.typeAnnotation, visitors);
+  walkNode(node.value, visitors);
+  exit !== null && exit(node);
+}
+
+function walkRestElement(node, visitors) {
+  let enterExit = visitors[77],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.decorators, visitors);
+  walkNode(node.argument, visitors);
+  walkNode(node.typeAnnotation, visitors);
+  exit !== null && exit(node);
+}
+
+function walkReturnStatement(node, visitors) {
+  let enterExit = visitors[78],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.argument, visitors);
+  exit !== null && exit(node);
+}
+
+function walkSequenceExpression(node, visitors) {
+  let enterExit = visitors[79],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.expressions, visitors);
+  exit !== null && exit(node);
+}
+
+function walkSpreadElement(node, visitors) {
+  let enterExit = visitors[80],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.argument, visitors);
+  exit !== null && exit(node);
+}
+
+function walkStaticBlock(node, visitors) {
+  let enterExit = visitors[81],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.body, visitors);
+  exit !== null && exit(node);
+}
+
+function walkSwitchCase(node, visitors) {
+  let enterExit = visitors[82],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.test, visitors);
+  walkNode(node.consequent, visitors);
+  exit !== null && exit(node);
+}
+
+function walkSwitchStatement(node, visitors) {
+  let enterExit = visitors[83],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.discriminant, visitors);
+  walkNode(node.cases, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTaggedTemplateExpression(node, visitors) {
+  let enterExit = visitors[84],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.tag, visitors);
+  walkNode(node.typeArguments, visitors);
+  walkNode(node.quasi, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTemplateLiteral(node, visitors) {
+  let enterExit = visitors[85],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.quasis, visitors);
+  walkNode(node.expressions, visitors);
+  exit !== null && exit(node);
+}
+
+function walkThrowStatement(node, visitors) {
+  let enterExit = visitors[86],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.argument, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTryStatement(node, visitors) {
+  let enterExit = visitors[87],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.block, visitors);
+  walkNode(node.handler, visitors);
+  walkNode(node.finalizer, visitors);
+  exit !== null && exit(node);
+}
+
+function walkUnaryExpression(node, visitors) {
+  let enterExit = visitors[88],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.argument, visitors);
+  exit !== null && exit(node);
+}
+
+function walkUpdateExpression(node, visitors) {
+  let enterExit = visitors[89],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.argument, visitors);
+  exit !== null && exit(node);
+}
+
+function walkV8IntrinsicExpression(node, visitors) {
+  let enterExit = visitors[90],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.name, visitors);
+  walkNode(node.arguments, visitors);
+  exit !== null && exit(node);
+}
+
+function walkVariableDeclaration(node, visitors) {
+  let enterExit = visitors[91],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.declarations, visitors);
+  exit !== null && exit(node);
+}
+
+function walkVariableDeclarator(node, visitors) {
+  let enterExit = visitors[92],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.id, visitors);
+  walkNode(node.init, visitors);
+  exit !== null && exit(node);
+}
+
+function walkWhileStatement(node, visitors) {
+  let enterExit = visitors[93],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.test, visitors);
+  walkNode(node.body, visitors);
+  exit !== null && exit(node);
+}
+
+function walkWithStatement(node, visitors) {
+  let enterExit = visitors[94],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.object, visitors);
+  walkNode(node.body, visitors);
+  exit !== null && exit(node);
+}
+
+function walkYieldExpression(node, visitors) {
+  let enterExit = visitors[95],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.argument, visitors);
+  exit !== null && exit(node);
+}
+
+function walkJSXAttribute(node, visitors) {
+  let enterExit = visitors[96],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.name, visitors);
+  walkNode(node.value, visitors);
+  exit !== null && exit(node);
+}
+
+function walkJSXClosingElement(node, visitors) {
+  let enterExit = visitors[97],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.name, visitors);
+  exit !== null && exit(node);
+}
+
+function walkJSXElement(node, visitors) {
+  let enterExit = visitors[98],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.openingElement, visitors);
+  walkNode(node.children, visitors);
+  walkNode(node.closingElement, visitors);
+  exit !== null && exit(node);
+}
+
+function walkJSXExpressionContainer(node, visitors) {
+  let enterExit = visitors[99],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.expression, visitors);
+  exit !== null && exit(node);
+}
+
+function walkJSXFragment(node, visitors) {
+  let enterExit = visitors[100],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.openingFragment, visitors);
+  walkNode(node.children, visitors);
+  walkNode(node.closingFragment, visitors);
+  exit !== null && exit(node);
+}
+
+function walkJSXMemberExpression(node, visitors) {
+  let enterExit = visitors[101],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.object, visitors);
+  walkNode(node.property, visitors);
+  exit !== null && exit(node);
+}
+
+function walkJSXNamespacedName(node, visitors) {
+  let enterExit = visitors[102],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.namespace, visitors);
+  walkNode(node.name, visitors);
+  exit !== null && exit(node);
+}
+
+function walkJSXOpeningElement(node, visitors) {
+  let enterExit = visitors[103],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.name, visitors);
+  walkNode(node.typeArguments, visitors);
+  walkNode(node.attributes, visitors);
+  exit !== null && exit(node);
+}
+
+function walkJSXSpreadAttribute(node, visitors) {
+  let enterExit = visitors[104],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.argument, visitors);
+  exit !== null && exit(node);
+}
+
+function walkJSXSpreadChild(node, visitors) {
+  let enterExit = visitors[105],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.expression, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSAbstractAccessorProperty(node, visitors) {
+  let enterExit = visitors[106],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.decorators, visitors);
+  walkNode(node.key, visitors);
+  walkNode(node.typeAnnotation, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSAbstractMethodDefinition(node, visitors) {
+  let enterExit = visitors[107],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.key, visitors);
+  walkNode(node.value, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSAbstractPropertyDefinition(node, visitors) {
+  let enterExit = visitors[108],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.decorators, visitors);
+  walkNode(node.key, visitors);
+  walkNode(node.typeAnnotation, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSArrayType(node, visitors) {
+  let enterExit = visitors[109],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.elementType, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSAsExpression(node, visitors) {
+  let enterExit = visitors[110],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.expression, visitors);
+  walkNode(node.typeAnnotation, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSCallSignatureDeclaration(node, visitors) {
+  let enterExit = visitors[111],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.typeParameters, visitors);
+  walkNode(node.params, visitors);
+  walkNode(node.returnType, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSClassImplements(node, visitors) {
+  let enterExit = visitors[112],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.expression, visitors);
+  walkNode(node.typeArguments, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSConditionalType(node, visitors) {
+  let enterExit = visitors[113],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.checkType, visitors);
+  walkNode(node.extendsType, visitors);
+  walkNode(node.trueType, visitors);
+  walkNode(node.falseType, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSConstructSignatureDeclaration(node, visitors) {
+  let enterExit = visitors[114],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.typeParameters, visitors);
+  walkNode(node.params, visitors);
+  walkNode(node.returnType, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSConstructorType(node, visitors) {
+  let enterExit = visitors[115],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.typeParameters, visitors);
+  walkNode(node.params, visitors);
+  walkNode(node.returnType, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSDeclareFunction(node, visitors) {
+  let enterExit = visitors[116],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.id, visitors);
+  walkNode(node.typeParameters, visitors);
+  walkNode(node.params, visitors);
+  walkNode(node.returnType, visitors);
+  walkNode(node.body, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSEmptyBodyFunctionExpression(node, visitors) {
+  let enterExit = visitors[117],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.id, visitors);
+  walkNode(node.typeParameters, visitors);
+  walkNode(node.params, visitors);
+  walkNode(node.returnType, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSEnumBody(node, visitors) {
+  let enterExit = visitors[118],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.members, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSEnumDeclaration(node, visitors) {
+  let enterExit = visitors[119],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.id, visitors);
+  walkNode(node.body, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSEnumMember(node, visitors) {
+  let enterExit = visitors[120],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.id, visitors);
+  walkNode(node.initializer, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSExportAssignment(node, visitors) {
+  let enterExit = visitors[121],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.expression, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSExternalModuleReference(node, visitors) {
+  let enterExit = visitors[122],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.expression, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSFunctionType(node, visitors) {
+  let enterExit = visitors[123],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.typeParameters, visitors);
+  walkNode(node.params, visitors);
+  walkNode(node.returnType, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSImportEqualsDeclaration(node, visitors) {
+  let enterExit = visitors[124],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.id, visitors);
+  walkNode(node.moduleReference, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSImportType(node, visitors) {
+  let enterExit = visitors[125],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.source, visitors);
+  walkNode(node.options, visitors);
+  walkNode(node.qualifier, visitors);
+  walkNode(node.typeArguments, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSIndexSignature(node, visitors) {
+  let enterExit = visitors[126],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.parameters, visitors);
+  walkNode(node.typeAnnotation, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSIndexedAccessType(node, visitors) {
+  let enterExit = visitors[127],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.objectType, visitors);
+  walkNode(node.indexType, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSInferType(node, visitors) {
+  let enterExit = visitors[128],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.typeParameter, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSInstantiationExpression(node, visitors) {
+  let enterExit = visitors[129],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.expression, visitors);
+  walkNode(node.typeArguments, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSInterfaceBody(node, visitors) {
+  let enterExit = visitors[130],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.body, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSInterfaceDeclaration(node, visitors) {
+  let enterExit = visitors[131],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.id, visitors);
+  walkNode(node.typeParameters, visitors);
+  walkNode(node.extends, visitors);
+  walkNode(node.body, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSInterfaceHeritage(node, visitors) {
+  let enterExit = visitors[132],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.expression, visitors);
+  walkNode(node.typeArguments, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSIntersectionType(node, visitors) {
+  let enterExit = visitors[133],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.types, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSJSDocNonNullableType(node, visitors) {
+  let enterExit = visitors[134],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.typeAnnotation, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSJSDocNullableType(node, visitors) {
+  let enterExit = visitors[135],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.typeAnnotation, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSLiteralType(node, visitors) {
+  let enterExit = visitors[136],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.literal, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSMappedType(node, visitors) {
+  let enterExit = visitors[137],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.key, visitors);
+  walkNode(node.constraint, visitors);
+  walkNode(node.nameType, visitors);
+  walkNode(node.typeAnnotation, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSMethodSignature(node, visitors) {
+  let enterExit = visitors[138],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.key, visitors);
+  walkNode(node.typeParameters, visitors);
+  walkNode(node.params, visitors);
+  walkNode(node.returnType, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSModuleBlock(node, visitors) {
+  let enterExit = visitors[139],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.body, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSModuleDeclaration(node, visitors) {
+  let enterExit = visitors[140],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.id, visitors);
+  walkNode(node.body, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSNamedTupleMember(node, visitors) {
+  let enterExit = visitors[141],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.label, visitors);
+  walkNode(node.elementType, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSNamespaceExportDeclaration(node, visitors) {
+  let enterExit = visitors[142],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.id, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSNonNullExpression(node, visitors) {
+  let enterExit = visitors[143],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.expression, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSOptionalType(node, visitors) {
+  let enterExit = visitors[144],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.typeAnnotation, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSParameterProperty(node, visitors) {
+  let enterExit = visitors[145],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.decorators, visitors);
+  walkNode(node.parameter, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSParenthesizedType(node, visitors) {
+  let enterExit = visitors[146],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.typeAnnotation, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSPropertySignature(node, visitors) {
+  let enterExit = visitors[147],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.key, visitors);
+  walkNode(node.typeAnnotation, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSQualifiedName(node, visitors) {
+  let enterExit = visitors[148],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.left, visitors);
+  walkNode(node.right, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSRestType(node, visitors) {
+  let enterExit = visitors[149],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.typeAnnotation, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSSatisfiesExpression(node, visitors) {
+  let enterExit = visitors[150],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.expression, visitors);
+  walkNode(node.typeAnnotation, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSTemplateLiteralType(node, visitors) {
+  let enterExit = visitors[151],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.quasis, visitors);
+  walkNode(node.types, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSTupleType(node, visitors) {
+  let enterExit = visitors[152],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.elementTypes, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSTypeAliasDeclaration(node, visitors) {
+  let enterExit = visitors[153],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.id, visitors);
+  walkNode(node.typeParameters, visitors);
+  walkNode(node.typeAnnotation, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSTypeAnnotation(node, visitors) {
+  let enterExit = visitors[154],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.typeAnnotation, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSTypeAssertion(node, visitors) {
+  let enterExit = visitors[155],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.typeAnnotation, visitors);
+  walkNode(node.expression, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSTypeLiteral(node, visitors) {
+  let enterExit = visitors[156],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.members, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSTypeOperator(node, visitors) {
+  let enterExit = visitors[157],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.typeAnnotation, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSTypeParameter(node, visitors) {
+  let enterExit = visitors[158],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.name, visitors);
+  walkNode(node.constraint, visitors);
+  walkNode(node.default, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSTypeParameterDeclaration(node, visitors) {
+  let enterExit = visitors[159],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.params, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSTypeParameterInstantiation(node, visitors) {
+  let enterExit = visitors[160],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.params, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSTypePredicate(node, visitors) {
+  let enterExit = visitors[161],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.parameterName, visitors);
+  walkNode(node.typeAnnotation, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSTypeQuery(node, visitors) {
+  let enterExit = visitors[162],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.exprName, visitors);
+  walkNode(node.typeArguments, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSTypeReference(node, visitors) {
+  let enterExit = visitors[163],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.typeName, visitors);
+  walkNode(node.typeArguments, visitors);
+  exit !== null && exit(node);
+}
+
+function walkTSUnionType(node, visitors) {
+  let enterExit = visitors[164],
+    exit = null,
+    enter;
+  if (enterExit !== null) {
+    ({ enter, exit } = enterExit);
+    enter !== null && enter(node);
+  }
+  walkNode(node.types, visitors);
+  exit !== null && exit(node);
+}