Brunobkr/llama.cpp_AlgMor24_github

1// Auto-generated code, DO NOT EDIT DIRECTLY!2// To edit this generated file you have to edit `tasks/ast_tools/src/generators/estree_visit.rs`.3 4export { walkProgram };5 6function walkNode(node, visitors) {7  if (node == null) return;8  if (Array.isArray(node)) {9    let len = node.length;10    for (let i = 0; i < len; i++) walkNode(node[i], visitors);11  } else12    switch (node.type) {13      case "DebuggerStatement":14        walkDebuggerStatement(node, visitors);15        break;16      case "EmptyStatement":17        walkEmptyStatement(node, visitors);18        break;19      case "Literal":20        walkLiteral(node, visitors);21        break;22      case "PrivateIdentifier":23        walkPrivateIdentifier(node, visitors);24        break;25      case "Super":26        walkSuper(node, visitors);27        break;28      case "TemplateElement":29        walkTemplateElement(node, visitors);30        break;31      case "ThisExpression":32        walkThisExpression(node, visitors);33        break;34      case "JSXClosingFragment":35        walkJSXClosingFragment(node, visitors);36        break;37      case "JSXEmptyExpression":38        walkJSXEmptyExpression(node, visitors);39        break;40      case "JSXIdentifier":41        walkJSXIdentifier(node, visitors);42        break;43      case "JSXOpeningFragment":44        walkJSXOpeningFragment(node, visitors);45        break;46      case "JSXText":47        walkJSXText(node, visitors);48        break;49      case "TSAnyKeyword":50        walkTSAnyKeyword(node, visitors);51        break;52      case "TSBigIntKeyword":53        walkTSBigIntKeyword(node, visitors);54        break;55      case "TSBooleanKeyword":56        walkTSBooleanKeyword(node, visitors);57        break;58      case "TSIntrinsicKeyword":59        walkTSIntrinsicKeyword(node, visitors);60        break;61      case "TSJSDocUnknownType":62        walkTSJSDocUnknownType(node, visitors);63        break;64      case "TSNeverKeyword":65        walkTSNeverKeyword(node, visitors);66        break;67      case "TSNullKeyword":68        walkTSNullKeyword(node, visitors);69        break;70      case "TSNumberKeyword":71        walkTSNumberKeyword(node, visitors);72        break;73      case "TSObjectKeyword":74        walkTSObjectKeyword(node, visitors);75        break;76      case "TSStringKeyword":77        walkTSStringKeyword(node, visitors);78        break;79      case "TSSymbolKeyword":80        walkTSSymbolKeyword(node, visitors);81        break;82      case "TSThisType":83        walkTSThisType(node, visitors);84        break;85      case "TSUndefinedKeyword":86        walkTSUndefinedKeyword(node, visitors);87        break;88      case "TSUnknownKeyword":89        walkTSUnknownKeyword(node, visitors);90        break;91      case "TSVoidKeyword":92        walkTSVoidKeyword(node, visitors);93        break;94      case "AccessorProperty":95        walkAccessorProperty(node, visitors);96        break;97      case "ArrayExpression":98        walkArrayExpression(node, visitors);99        break;100      case "ArrayPattern":101        walkArrayPattern(node, visitors);102        break;103      case "ArrowFunctionExpression":104        walkArrowFunctionExpression(node, visitors);105        break;106      case "AssignmentExpression":107        walkAssignmentExpression(node, visitors);108        break;109      case "AssignmentPattern":110        walkAssignmentPattern(node, visitors);111        break;112      case "AwaitExpression":113        walkAwaitExpression(node, visitors);114        break;115      case "BinaryExpression":116        walkBinaryExpression(node, visitors);117        break;118      case "BlockStatement":119        walkBlockStatement(node, visitors);120        break;121      case "BreakStatement":122        walkBreakStatement(node, visitors);123        break;124      case "CallExpression":125        walkCallExpression(node, visitors);126        break;127      case "CatchClause":128        walkCatchClause(node, visitors);129        break;130      case "ChainExpression":131        walkChainExpression(node, visitors);132        break;133      case "ClassBody":134        walkClassBody(node, visitors);135        break;136      case "ClassDeclaration":137        walkClassDeclaration(node, visitors);138        break;139      case "ClassExpression":140        walkClassExpression(node, visitors);141        break;142      case "ConditionalExpression":143        walkConditionalExpression(node, visitors);144        break;145      case "ContinueStatement":146        walkContinueStatement(node, visitors);147        break;148      case "Decorator":149        walkDecorator(node, visitors);150        break;151      case "DoWhileStatement":152        walkDoWhileStatement(node, visitors);153        break;154      case "ExportAllDeclaration":155        walkExportAllDeclaration(node, visitors);156        break;157      case "ExportDefaultDeclaration":158        walkExportDefaultDeclaration(node, visitors);159        break;160      case "ExportNamedDeclaration":161        walkExportNamedDeclaration(node, visitors);162        break;163      case "ExportSpecifier":164        walkExportSpecifier(node, visitors);165        break;166      case "ExpressionStatement":167        walkExpressionStatement(node, visitors);168        break;169      case "ForInStatement":170        walkForInStatement(node, visitors);171        break;172      case "ForOfStatement":173        walkForOfStatement(node, visitors);174        break;175      case "ForStatement":176        walkForStatement(node, visitors);177        break;178      case "FunctionDeclaration":179        walkFunctionDeclaration(node, visitors);180        break;181      case "FunctionExpression":182        walkFunctionExpression(node, visitors);183        break;184      case "Identifier":185        walkIdentifier(node, visitors);186        break;187      case "IfStatement":188        walkIfStatement(node, visitors);189        break;190      case "ImportAttribute":191        walkImportAttribute(node, visitors);192        break;193      case "ImportDeclaration":194        walkImportDeclaration(node, visitors);195        break;196      case "ImportDefaultSpecifier":197        walkImportDefaultSpecifier(node, visitors);198        break;199      case "ImportExpression":200        walkImportExpression(node, visitors);201        break;202      case "ImportNamespaceSpecifier":203        walkImportNamespaceSpecifier(node, visitors);204        break;205      case "ImportSpecifier":206        walkImportSpecifier(node, visitors);207        break;208      case "LabeledStatement":209        walkLabeledStatement(node, visitors);210        break;211      case "LogicalExpression":212        walkLogicalExpression(node, visitors);213        break;214      case "MemberExpression":215        walkMemberExpression(node, visitors);216        break;217      case "MetaProperty":218        walkMetaProperty(node, visitors);219        break;220      case "MethodDefinition":221        walkMethodDefinition(node, visitors);222        break;223      case "NewExpression":224        walkNewExpression(node, visitors);225        break;226      case "ObjectExpression":227        walkObjectExpression(node, visitors);228        break;229      case "ObjectPattern":230        walkObjectPattern(node, visitors);231        break;232      case "ParenthesizedExpression":233        walkParenthesizedExpression(node, visitors);234        break;235      case "Program":236        walkProgram(node, visitors);237        break;238      case "Property":239        walkProperty(node, visitors);240        break;241      case "PropertyDefinition":242        walkPropertyDefinition(node, visitors);243        break;244      case "RestElement":245        walkRestElement(node, visitors);246        break;247      case "ReturnStatement":248        walkReturnStatement(node, visitors);249        break;250      case "SequenceExpression":251        walkSequenceExpression(node, visitors);252        break;253      case "SpreadElement":254        walkSpreadElement(node, visitors);255        break;256      case "StaticBlock":257        walkStaticBlock(node, visitors);258        break;259      case "SwitchCase":260        walkSwitchCase(node, visitors);261        break;262      case "SwitchStatement":263        walkSwitchStatement(node, visitors);264        break;265      case "TaggedTemplateExpression":266        walkTaggedTemplateExpression(node, visitors);267        break;268      case "TemplateLiteral":269        walkTemplateLiteral(node, visitors);270        break;271      case "ThrowStatement":272        walkThrowStatement(node, visitors);273        break;274      case "TryStatement":275        walkTryStatement(node, visitors);276        break;277      case "UnaryExpression":278        walkUnaryExpression(node, visitors);279        break;280      case "UpdateExpression":281        walkUpdateExpression(node, visitors);282        break;283      case "V8IntrinsicExpression":284        walkV8IntrinsicExpression(node, visitors);285        break;286      case "VariableDeclaration":287        walkVariableDeclaration(node, visitors);288        break;289      case "VariableDeclarator":290        walkVariableDeclarator(node, visitors);291        break;292      case "WhileStatement":293        walkWhileStatement(node, visitors);294        break;295      case "WithStatement":296        walkWithStatement(node, visitors);297        break;298      case "YieldExpression":299        walkYieldExpression(node, visitors);300        break;301      case "JSXAttribute":302        walkJSXAttribute(node, visitors);303        break;304      case "JSXClosingElement":305        walkJSXClosingElement(node, visitors);306        break;307      case "JSXElement":308        walkJSXElement(node, visitors);309        break;310      case "JSXExpressionContainer":311        walkJSXExpressionContainer(node, visitors);312        break;313      case "JSXFragment":314        walkJSXFragment(node, visitors);315        break;316      case "JSXMemberExpression":317        walkJSXMemberExpression(node, visitors);318        break;319      case "JSXNamespacedName":320        walkJSXNamespacedName(node, visitors);321        break;322      case "JSXOpeningElement":323        walkJSXOpeningElement(node, visitors);324        break;325      case "JSXSpreadAttribute":326        walkJSXSpreadAttribute(node, visitors);327        break;328      case "JSXSpreadChild":329        walkJSXSpreadChild(node, visitors);330        break;331      case "TSAbstractAccessorProperty":332        walkTSAbstractAccessorProperty(node, visitors);333        break;334      case "TSAbstractMethodDefinition":335        walkTSAbstractMethodDefinition(node, visitors);336        break;337      case "TSAbstractPropertyDefinition":338        walkTSAbstractPropertyDefinition(node, visitors);339        break;340      case "TSArrayType":341        walkTSArrayType(node, visitors);342        break;343      case "TSAsExpression":344        walkTSAsExpression(node, visitors);345        break;346      case "TSCallSignatureDeclaration":347        walkTSCallSignatureDeclaration(node, visitors);348        break;349      case "TSClassImplements":350        walkTSClassImplements(node, visitors);351        break;352      case "TSConditionalType":353        walkTSConditionalType(node, visitors);354        break;355      case "TSConstructSignatureDeclaration":356        walkTSConstructSignatureDeclaration(node, visitors);357        break;358      case "TSConstructorType":359        walkTSConstructorType(node, visitors);360        break;361      case "TSDeclareFunction":362        walkTSDeclareFunction(node, visitors);363        break;364      case "TSEmptyBodyFunctionExpression":365        walkTSEmptyBodyFunctionExpression(node, visitors);366        break;367      case "TSEnumBody":368        walkTSEnumBody(node, visitors);369        break;370      case "TSEnumDeclaration":371        walkTSEnumDeclaration(node, visitors);372        break;373      case "TSEnumMember":374        walkTSEnumMember(node, visitors);375        break;376      case "TSExportAssignment":377        walkTSExportAssignment(node, visitors);378        break;379      case "TSExternalModuleReference":380        walkTSExternalModuleReference(node, visitors);381        break;382      case "TSFunctionType":383        walkTSFunctionType(node, visitors);384        break;385      case "TSImportEqualsDeclaration":386        walkTSImportEqualsDeclaration(node, visitors);387        break;388      case "TSImportType":389        walkTSImportType(node, visitors);390        break;391      case "TSIndexSignature":392        walkTSIndexSignature(node, visitors);393        break;394      case "TSIndexedAccessType":395        walkTSIndexedAccessType(node, visitors);396        break;397      case "TSInferType":398        walkTSInferType(node, visitors);399        break;400      case "TSInstantiationExpression":401        walkTSInstantiationExpression(node, visitors);402        break;403      case "TSInterfaceBody":404        walkTSInterfaceBody(node, visitors);405        break;406      case "TSInterfaceDeclaration":407        walkTSInterfaceDeclaration(node, visitors);408        break;409      case "TSInterfaceHeritage":410        walkTSInterfaceHeritage(node, visitors);411        break;412      case "TSIntersectionType":413        walkTSIntersectionType(node, visitors);414        break;415      case "TSJSDocNonNullableType":416        walkTSJSDocNonNullableType(node, visitors);417        break;418      case "TSJSDocNullableType":419        walkTSJSDocNullableType(node, visitors);420        break;421      case "TSLiteralType":422        walkTSLiteralType(node, visitors);423        break;424      case "TSMappedType":425        walkTSMappedType(node, visitors);426        break;427      case "TSMethodSignature":428        walkTSMethodSignature(node, visitors);429        break;430      case "TSModuleBlock":431        walkTSModuleBlock(node, visitors);432        break;433      case "TSModuleDeclaration":434        walkTSModuleDeclaration(node, visitors);435        break;436      case "TSNamedTupleMember":437        walkTSNamedTupleMember(node, visitors);438        break;439      case "TSNamespaceExportDeclaration":440        walkTSNamespaceExportDeclaration(node, visitors);441        break;442      case "TSNonNullExpression":443        walkTSNonNullExpression(node, visitors);444        break;445      case "TSOptionalType":446        walkTSOptionalType(node, visitors);447        break;448      case "TSParameterProperty":449        walkTSParameterProperty(node, visitors);450        break;451      case "TSParenthesizedType":452        walkTSParenthesizedType(node, visitors);453        break;454      case "TSPropertySignature":455        walkTSPropertySignature(node, visitors);456        break;457      case "TSQualifiedName":458        walkTSQualifiedName(node, visitors);459        break;460      case "TSRestType":461        walkTSRestType(node, visitors);462        break;463      case "TSSatisfiesExpression":464        walkTSSatisfiesExpression(node, visitors);465        break;466      case "TSTemplateLiteralType":467        walkTSTemplateLiteralType(node, visitors);468        break;469      case "TSTupleType":470        walkTSTupleType(node, visitors);471        break;472      case "TSTypeAliasDeclaration":473        walkTSTypeAliasDeclaration(node, visitors);474        break;475      case "TSTypeAnnotation":476        walkTSTypeAnnotation(node, visitors);477        break;478      case "TSTypeAssertion":479        walkTSTypeAssertion(node, visitors);480        break;481      case "TSTypeLiteral":482        walkTSTypeLiteral(node, visitors);483        break;484      case "TSTypeOperator":485        walkTSTypeOperator(node, visitors);486        break;487      case "TSTypeParameter":488        walkTSTypeParameter(node, visitors);489        break;490      case "TSTypeParameterDeclaration":491        walkTSTypeParameterDeclaration(node, visitors);492        break;493      case "TSTypeParameterInstantiation":494        walkTSTypeParameterInstantiation(node, visitors);495        break;496      case "TSTypePredicate":497        walkTSTypePredicate(node, visitors);498        break;499      case "TSTypeQuery":500        walkTSTypeQuery(node, visitors);501        break;502      case "TSTypeReference":503        walkTSTypeReference(node, visitors);504        break;505      case "TSUnionType":506        walkTSUnionType(node, visitors);507        break;508    }509}510 511function walkDebuggerStatement(node, visitors) {512  let visit = visitors[0];513  visit !== null && visit(node);514}515 516function walkEmptyStatement(node, visitors) {517  let visit = visitors[1];518  visit !== null && visit(node);519}520 521function walkLiteral(node, visitors) {522  let visit = visitors[2];523  visit !== null && visit(node);524}525 526function walkPrivateIdentifier(node, visitors) {527  let visit = visitors[3];528  visit !== null && visit(node);529}530 531function walkSuper(node, visitors) {532  let visit = visitors[4];533  visit !== null && visit(node);534}535 536function walkTemplateElement(node, visitors) {537  let visit = visitors[5];538  visit !== null && visit(node);539}540 541function walkThisExpression(node, visitors) {542  let visit = visitors[6];543  visit !== null && visit(node);544}545 546function walkJSXClosingFragment(node, visitors) {547  let visit = visitors[7];548  visit !== null && visit(node);549}550 551function walkJSXEmptyExpression(node, visitors) {552  let visit = visitors[8];553  visit !== null && visit(node);554}555 556function walkJSXIdentifier(node, visitors) {557  let visit = visitors[9];558  visit !== null && visit(node);559}560 561function walkJSXOpeningFragment(node, visitors) {562  let visit = visitors[10];563  visit !== null && visit(node);564}565 566function walkJSXText(node, visitors) {567  let visit = visitors[11];568  visit !== null && visit(node);569}570 571function walkTSAnyKeyword(node, visitors) {572  let visit = visitors[12];573  visit !== null && visit(node);574}575 576function walkTSBigIntKeyword(node, visitors) {577  let visit = visitors[13];578  visit !== null && visit(node);579}580 581function walkTSBooleanKeyword(node, visitors) {582  let visit = visitors[14];583  visit !== null && visit(node);584}585 586function walkTSIntrinsicKeyword(node, visitors) {587  let visit = visitors[15];588  visit !== null && visit(node);589}590 591function walkTSJSDocUnknownType(node, visitors) {592  let visit = visitors[16];593  visit !== null && visit(node);594}595 596function walkTSNeverKeyword(node, visitors) {597  let visit = visitors[17];598  visit !== null && visit(node);599}600 601function walkTSNullKeyword(node, visitors) {602  let visit = visitors[18];603  visit !== null && visit(node);604}605 606function walkTSNumberKeyword(node, visitors) {607  let visit = visitors[19];608  visit !== null && visit(node);609}610 611function walkTSObjectKeyword(node, visitors) {612  let visit = visitors[20];613  visit !== null && visit(node);614}615 616function walkTSStringKeyword(node, visitors) {617  let visit = visitors[21];618  visit !== null && visit(node);619}620 621function walkTSSymbolKeyword(node, visitors) {622  let visit = visitors[22];623  visit !== null && visit(node);624}625 626function walkTSThisType(node, visitors) {627  let visit = visitors[23];628  visit !== null && visit(node);629}630 631function walkTSUndefinedKeyword(node, visitors) {632  let visit = visitors[24];633  visit !== null && visit(node);634}635 636function walkTSUnknownKeyword(node, visitors) {637  let visit = visitors[25];638  visit !== null && visit(node);639}640 641function walkTSVoidKeyword(node, visitors) {642  let visit = visitors[26];643  visit !== null && visit(node);644}645 646function walkAccessorProperty(node, visitors) {647  let enterExit = visitors[27],648    exit = null,649    enter;650  if (enterExit !== null) {651    ({ enter, exit } = enterExit);652    enter !== null && enter(node);653  }654  walkNode(node.decorators, visitors);655  walkNode(node.key, visitors);656  walkNode(node.typeAnnotation, visitors);657  walkNode(node.value, visitors);658  exit !== null && exit(node);659}660 661function walkArrayExpression(node, visitors) {662  let enterExit = visitors[28],663    exit = null,664    enter;665  if (enterExit !== null) {666    ({ enter, exit } = enterExit);667    enter !== null && enter(node);668  }669  walkNode(node.elements, visitors);670  exit !== null && exit(node);671}672 673function walkArrayPattern(node, visitors) {674  let enterExit = visitors[29],675    exit = null,676    enter;677  if (enterExit !== null) {678    ({ enter, exit } = enterExit);679    enter !== null && enter(node);680  }681  walkNode(node.decorators, visitors);682  walkNode(node.elements, visitors);683  walkNode(node.typeAnnotation, visitors);684  exit !== null && exit(node);685}686 687function walkArrowFunctionExpression(node, visitors) {688  let enterExit = visitors[30],689    exit = null,690    enter;691  if (enterExit !== null) {692    ({ enter, exit } = enterExit);693    enter !== null && enter(node);694  }695  walkNode(node.typeParameters, visitors);696  walkNode(node.params, visitors);697  walkNode(node.returnType, visitors);698  walkNode(node.body, visitors);699  exit !== null && exit(node);700}701 702function walkAssignmentExpression(node, visitors) {703  let enterExit = visitors[31],704    exit = null,705    enter;706  if (enterExit !== null) {707    ({ enter, exit } = enterExit);708    enter !== null && enter(node);709  }710  walkNode(node.left, visitors);711  walkNode(node.right, visitors);712  exit !== null && exit(node);713}714 715function walkAssignmentPattern(node, visitors) {716  let enterExit = visitors[32],717    exit = null,718    enter;719  if (enterExit !== null) {720    ({ enter, exit } = enterExit);721    enter !== null && enter(node);722  }723  walkNode(node.decorators, visitors);724  walkNode(node.left, visitors);725  walkNode(node.right, visitors);726  walkNode(node.typeAnnotation, visitors);727  exit !== null && exit(node);728}729 730function walkAwaitExpression(node, visitors) {731  let enterExit = visitors[33],732    exit = null,733    enter;734  if (enterExit !== null) {735    ({ enter, exit } = enterExit);736    enter !== null && enter(node);737  }738  walkNode(node.argument, visitors);739  exit !== null && exit(node);740}741 742function walkBinaryExpression(node, visitors) {743  let enterExit = visitors[34],744    exit = null,745    enter;746  if (enterExit !== null) {747    ({ enter, exit } = enterExit);748    enter !== null && enter(node);749  }750  walkNode(node.left, visitors);751  walkNode(node.right, visitors);752  exit !== null && exit(node);753}754 755function walkBlockStatement(node, visitors) {756  let enterExit = visitors[35],757    exit = null,758    enter;759  if (enterExit !== null) {760    ({ enter, exit } = enterExit);761    enter !== null && enter(node);762  }763  walkNode(node.body, visitors);764  exit !== null && exit(node);765}766 767function walkBreakStatement(node, visitors) {768  let enterExit = visitors[36],769    exit = null,770    enter;771  if (enterExit !== null) {772    ({ enter, exit } = enterExit);773    enter !== null && enter(node);774  }775  walkNode(node.label, visitors);776  exit !== null && exit(node);777}778 779function walkCallExpression(node, visitors) {780  let enterExit = visitors[37],781    exit = null,782    enter;783  if (enterExit !== null) {784    ({ enter, exit } = enterExit);785    enter !== null && enter(node);786  }787  walkNode(node.callee, visitors);788  walkNode(node.typeArguments, visitors);789  walkNode(node.arguments, visitors);790  exit !== null && exit(node);791}792 793function walkCatchClause(node, visitors) {794  let enterExit = visitors[38],795    exit = null,796    enter;797  if (enterExit !== null) {798    ({ enter, exit } = enterExit);799    enter !== null && enter(node);800  }801  walkNode(node.param, visitors);802  walkNode(node.body, visitors);803  exit !== null && exit(node);804}805 806function walkChainExpression(node, visitors) {807  let enterExit = visitors[39],808    exit = null,809    enter;810  if (enterExit !== null) {811    ({ enter, exit } = enterExit);812    enter !== null && enter(node);813  }814  walkNode(node.expression, visitors);815  exit !== null && exit(node);816}817 818function walkClassBody(node, visitors) {819  let enterExit = visitors[40],820    exit = null,821    enter;822  if (enterExit !== null) {823    ({ enter, exit } = enterExit);824    enter !== null && enter(node);825  }826  walkNode(node.body, visitors);827  exit !== null && exit(node);828}829 830function walkClassDeclaration(node, visitors) {831  let enterExit = visitors[41],832    exit = null,833    enter;834  if (enterExit !== null) {835    ({ enter, exit } = enterExit);836    enter !== null && enter(node);837  }838  walkNode(node.decorators, visitors);839  walkNode(node.id, visitors);840  walkNode(node.typeParameters, visitors);841  walkNode(node.superClass, visitors);842  walkNode(node.superTypeArguments, visitors);843  walkNode(node.implements, visitors);844  walkNode(node.body, visitors);845  exit !== null && exit(node);846}847 848function walkClassExpression(node, visitors) {849  let enterExit = visitors[42],850    exit = null,851    enter;852  if (enterExit !== null) {853    ({ enter, exit } = enterExit);854    enter !== null && enter(node);855  }856  walkNode(node.decorators, visitors);857  walkNode(node.id, visitors);858  walkNode(node.typeParameters, visitors);859  walkNode(node.superClass, visitors);860  walkNode(node.superTypeArguments, visitors);861  walkNode(node.implements, visitors);862  walkNode(node.body, visitors);863  exit !== null && exit(node);864}865 866function walkConditionalExpression(node, visitors) {867  let enterExit = visitors[43],868    exit = null,869    enter;870  if (enterExit !== null) {871    ({ enter, exit } = enterExit);872    enter !== null && enter(node);873  }874  walkNode(node.test, visitors);875  walkNode(node.consequent, visitors);876  walkNode(node.alternate, visitors);877  exit !== null && exit(node);878}879 880function walkContinueStatement(node, visitors) {881  let enterExit = visitors[44],882    exit = null,883    enter;884  if (enterExit !== null) {885    ({ enter, exit } = enterExit);886    enter !== null && enter(node);887  }888  walkNode(node.label, visitors);889  exit !== null && exit(node);890}891 892function walkDecorator(node, visitors) {893  let enterExit = visitors[45],894    exit = null,895    enter;896  if (enterExit !== null) {897    ({ enter, exit } = enterExit);898    enter !== null && enter(node);899  }900  walkNode(node.expression, visitors);901  exit !== null && exit(node);902}903 904function walkDoWhileStatement(node, visitors) {905  let enterExit = visitors[46],906    exit = null,907    enter;908  if (enterExit !== null) {909    ({ enter, exit } = enterExit);910    enter !== null && enter(node);911  }912  walkNode(node.body, visitors);913  walkNode(node.test, visitors);914  exit !== null && exit(node);915}916 917function walkExportAllDeclaration(node, visitors) {918  let enterExit = visitors[47],919    exit = null,920    enter;921  if (enterExit !== null) {922    ({ enter, exit } = enterExit);923    enter !== null && enter(node);924  }925  walkNode(node.exported, visitors);926  walkNode(node.source, visitors);927  walkNode(node.attributes, visitors);928  exit !== null && exit(node);929}930 931function walkExportDefaultDeclaration(node, visitors) {932  let enterExit = visitors[48],933    exit = null,934    enter;935  if (enterExit !== null) {936    ({ enter, exit } = enterExit);937    enter !== null && enter(node);938  }939  walkNode(node.declaration, visitors);940  exit !== null && exit(node);941}942 943function walkExportNamedDeclaration(node, visitors) {944  let enterExit = visitors[49],945    exit = null,946    enter;947  if (enterExit !== null) {948    ({ enter, exit } = enterExit);949    enter !== null && enter(node);950  }951  walkNode(node.declaration, visitors);952  walkNode(node.specifiers, visitors);953  walkNode(node.source, visitors);954  walkNode(node.attributes, visitors);955  exit !== null && exit(node);956}957 958function walkExportSpecifier(node, visitors) {959  let enterExit = visitors[50],960    exit = null,961    enter;962  if (enterExit !== null) {963    ({ enter, exit } = enterExit);964    enter !== null && enter(node);965  }966  walkNode(node.local, visitors);967  walkNode(node.exported, visitors);968  exit !== null && exit(node);969}970 971function walkExpressionStatement(node, visitors) {972  let enterExit = visitors[51],973    exit = null,974    enter;975  if (enterExit !== null) {976    ({ enter, exit } = enterExit);977    enter !== null && enter(node);978  }979  walkNode(node.expression, visitors);980  exit !== null && exit(node);981}982 983function walkForInStatement(node, visitors) {984  let enterExit = visitors[52],985    exit = null,986    enter;987  if (enterExit !== null) {988    ({ enter, exit } = enterExit);989    enter !== null && enter(node);990  }991  walkNode(node.left, visitors);992  walkNode(node.right, visitors);993  walkNode(node.body, visitors);994  exit !== null && exit(node);995}996 997function walkForOfStatement(node, visitors) {998  let enterExit = visitors[53],999    exit = null,1000    enter;1001  if (enterExit !== null) {1002    ({ enter, exit } = enterExit);1003    enter !== null && enter(node);1004  }1005  walkNode(node.left, visitors);1006  walkNode(node.right, visitors);1007  walkNode(node.body, visitors);1008  exit !== null && exit(node);1009}1010 1011function walkForStatement(node, visitors) {1012  let enterExit = visitors[54],1013    exit = null,1014    enter;1015  if (enterExit !== null) {1016    ({ enter, exit } = enterExit);1017    enter !== null && enter(node);1018  }1019  walkNode(node.init, visitors);1020  walkNode(node.test, visitors);1021  walkNode(node.update, visitors);1022  walkNode(node.body, visitors);1023  exit !== null && exit(node);1024}1025 1026function walkFunctionDeclaration(node, visitors) {1027  let enterExit = visitors[55],1028    exit = null,1029    enter;1030  if (enterExit !== null) {1031    ({ enter, exit } = enterExit);1032    enter !== null && enter(node);1033  }1034  walkNode(node.id, visitors);1035  walkNode(node.typeParameters, visitors);1036  walkNode(node.params, visitors);1037  walkNode(node.returnType, visitors);1038  walkNode(node.body, visitors);1039  exit !== null && exit(node);1040}1041 1042function walkFunctionExpression(node, visitors) {1043  let enterExit = visitors[56],1044    exit = null,1045    enter;1046  if (enterExit !== null) {1047    ({ enter, exit } = enterExit);1048    enter !== null && enter(node);1049  }1050  walkNode(node.id, visitors);1051  walkNode(node.typeParameters, visitors);1052  walkNode(node.params, visitors);1053  walkNode(node.returnType, visitors);1054  walkNode(node.body, visitors);1055  exit !== null && exit(node);1056}1057 1058function walkIdentifier(node, visitors) {1059  let enterExit = visitors[57],1060    exit = null,1061    enter;1062  if (enterExit !== null) {1063    ({ enter, exit } = enterExit);1064    enter !== null && enter(node);1065  }1066  walkNode(node.decorators, visitors);1067  walkNode(node.typeAnnotation, visitors);1068  exit !== null && exit(node);1069}1070 1071function walkIfStatement(node, visitors) {1072  let enterExit = visitors[58],1073    exit = null,1074    enter;1075  if (enterExit !== null) {1076    ({ enter, exit } = enterExit);1077    enter !== null && enter(node);1078  }1079  walkNode(node.test, visitors);1080  walkNode(node.consequent, visitors);1081  walkNode(node.alternate, visitors);1082  exit !== null && exit(node);1083}1084 1085function walkImportAttribute(node, visitors) {1086  let enterExit = visitors[59],1087    exit = null,1088    enter;1089  if (enterExit !== null) {1090    ({ enter, exit } = enterExit);1091    enter !== null && enter(node);1092  }1093  walkNode(node.key, visitors);1094  walkNode(node.value, visitors);1095  exit !== null && exit(node);1096}1097 1098function walkImportDeclaration(node, visitors) {1099  let enterExit = visitors[60],1100    exit = null,1101    enter;1102  if (enterExit !== null) {1103    ({ enter, exit } = enterExit);1104    enter !== null && enter(node);1105  }1106  walkNode(node.specifiers, visitors);1107  walkNode(node.source, visitors);1108  walkNode(node.attributes, visitors);1109  exit !== null && exit(node);1110}1111 1112function walkImportDefaultSpecifier(node, visitors) {1113  let enterExit = visitors[61],1114    exit = null,1115    enter;1116  if (enterExit !== null) {1117    ({ enter, exit } = enterExit);1118    enter !== null && enter(node);1119  }1120  walkNode(node.local, visitors);1121  exit !== null && exit(node);1122}1123 1124function walkImportExpression(node, visitors) {1125  let enterExit = visitors[62],1126    exit = null,1127    enter;1128  if (enterExit !== null) {1129    ({ enter, exit } = enterExit);1130    enter !== null && enter(node);1131  }1132  walkNode(node.source, visitors);1133  walkNode(node.options, visitors);1134  exit !== null && exit(node);1135}1136 1137function walkImportNamespaceSpecifier(node, visitors) {1138  let enterExit = visitors[63],1139    exit = null,1140    enter;1141  if (enterExit !== null) {1142    ({ enter, exit } = enterExit);1143    enter !== null && enter(node);1144  }1145  walkNode(node.local, visitors);1146  exit !== null && exit(node);1147}1148 1149function walkImportSpecifier(node, visitors) {1150  let enterExit = visitors[64],1151    exit = null,1152    enter;1153  if (enterExit !== null) {1154    ({ enter, exit } = enterExit);1155    enter !== null && enter(node);1156  }1157  walkNode(node.imported, visitors);1158  walkNode(node.local, visitors);1159  exit !== null && exit(node);1160}1161 1162function walkLabeledStatement(node, visitors) {1163  let enterExit = visitors[65],1164    exit = null,1165    enter;1166  if (enterExit !== null) {1167    ({ enter, exit } = enterExit);1168    enter !== null && enter(node);1169  }1170  walkNode(node.label, visitors);1171  walkNode(node.body, visitors);1172  exit !== null && exit(node);1173}1174 1175function walkLogicalExpression(node, visitors) {1176  let enterExit = visitors[66],1177    exit = null,1178    enter;1179  if (enterExit !== null) {1180    ({ enter, exit } = enterExit);1181    enter !== null && enter(node);1182  }1183  walkNode(node.left, visitors);1184  walkNode(node.right, visitors);1185  exit !== null && exit(node);1186}1187 1188function walkMemberExpression(node, visitors) {1189  let enterExit = visitors[67],1190    exit = null,1191    enter;1192  if (enterExit !== null) {1193    ({ enter, exit } = enterExit);1194    enter !== null && enter(node);1195  }1196  walkNode(node.object, visitors);1197  walkNode(node.property, visitors);1198  exit !== null && exit(node);1199}1200 

Showing the first 1,200 of 2456 lines. Download the file for the rest.