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