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