| Server IP : 167.235.224.122 / Your IP : 216.73.216.110 Web Server : Apache/2.4.58 (Ubuntu) System : Linux newplayground 6.8.0-136-generic #136-Ubuntu SMP PREEMPT_DYNAMIC Wed Jul 1 21:33:11 UTC 2026 aarch64 User : deploy ( 1000) PHP Version : 8.4.23 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF Directory : /var/www/html/reef_analytics/node_modules/rolldown/dist/ |
Upload File : |
import { n as parseSync, t as parse } from "./shared/parse-D4dtlfWy.mjs";
import { a as minify, i as transformSync, o as minifySync, r as transform, t as TsconfigCache } from "./shared/resolve-tsconfig-DxqIJB3x.mjs";
//#region ../../node_modules/.pnpm/oxc-parser@0.139.0/node_modules/oxc-parser/src-js/generated/visit/walk.js
function walkNode(node, visitors) {
if (node == null) return;
if (Array.isArray(node)) {
let len = node.length;
for (let i = 0; i < len; i++) walkNode(node[i], visitors);
} else switch (node.type) {
case "DebuggerStatement":
walkDebuggerStatement(node, visitors);
break;
case "EmptyStatement":
walkEmptyStatement(node, visitors);
break;
case "Literal":
walkLiteral(node, visitors);
break;
case "PrivateIdentifier":
walkPrivateIdentifier(node, visitors);
break;
case "Super":
walkSuper(node, visitors);
break;
case "TemplateElement":
walkTemplateElement(node, visitors);
break;
case "ThisExpression":
walkThisExpression(node, visitors);
break;
case "JSXClosingFragment":
walkJSXClosingFragment(node, visitors);
break;
case "JSXEmptyExpression":
walkJSXEmptyExpression(node, visitors);
break;
case "JSXIdentifier":
walkJSXIdentifier(node, visitors);
break;
case "JSXOpeningFragment":
walkJSXOpeningFragment(node, visitors);
break;
case "JSXText":
walkJSXText(node, visitors);
break;
case "TSAnyKeyword":
walkTSAnyKeyword(node, visitors);
break;
case "TSBigIntKeyword":
walkTSBigIntKeyword(node, visitors);
break;
case "TSBooleanKeyword":
walkTSBooleanKeyword(node, visitors);
break;
case "TSIntrinsicKeyword":
walkTSIntrinsicKeyword(node, visitors);
break;
case "TSJSDocUnknownType":
walkTSJSDocUnknownType(node, visitors);
break;
case "TSNeverKeyword":
walkTSNeverKeyword(node, visitors);
break;
case "TSNullKeyword":
walkTSNullKeyword(node, visitors);
break;
case "TSNumberKeyword":
walkTSNumberKeyword(node, visitors);
break;
case "TSObjectKeyword":
walkTSObjectKeyword(node, visitors);
break;
case "TSStringKeyword":
walkTSStringKeyword(node, visitors);
break;
case "TSSymbolKeyword":
walkTSSymbolKeyword(node, visitors);
break;
case "TSThisType":
walkTSThisType(node, visitors);
break;
case "TSUndefinedKeyword":
walkTSUndefinedKeyword(node, visitors);
break;
case "TSUnknownKeyword":
walkTSUnknownKeyword(node, visitors);
break;
case "TSVoidKeyword":
walkTSVoidKeyword(node, visitors);
break;
case "AccessorProperty":
walkAccessorProperty(node, visitors);
break;
case "ArrayExpression":
walkArrayExpression(node, visitors);
break;
case "ArrayPattern":
walkArrayPattern(node, visitors);
break;
case "ArrowFunctionExpression":
walkArrowFunctionExpression(node, visitors);
break;
case "AssignmentExpression":
walkAssignmentExpression(node, visitors);
break;
case "AssignmentPattern":
walkAssignmentPattern(node, visitors);
break;
case "AwaitExpression":
walkAwaitExpression(node, visitors);
break;
case "BinaryExpression":
walkBinaryExpression(node, visitors);
break;
case "BlockStatement":
walkBlockStatement(node, visitors);
break;
case "BreakStatement":
walkBreakStatement(node, visitors);
break;
case "CallExpression":
walkCallExpression(node, visitors);
break;
case "CatchClause":
walkCatchClause(node, visitors);
break;
case "ChainExpression":
walkChainExpression(node, visitors);
break;
case "ClassBody":
walkClassBody(node, visitors);
break;
case "ClassDeclaration":
walkClassDeclaration(node, visitors);
break;
case "ClassExpression":
walkClassExpression(node, visitors);
break;
case "ConditionalExpression":
walkConditionalExpression(node, visitors);
break;
case "ContinueStatement":
walkContinueStatement(node, visitors);
break;
case "Decorator":
walkDecorator(node, visitors);
break;
case "DoWhileStatement":
walkDoWhileStatement(node, visitors);
break;
case "ExportAllDeclaration":
walkExportAllDeclaration(node, visitors);
break;
case "ExportDefaultDeclaration":
walkExportDefaultDeclaration(node, visitors);
break;
case "ExportNamedDeclaration":
walkExportNamedDeclaration(node, visitors);
break;
case "ExportSpecifier":
walkExportSpecifier(node, visitors);
break;
case "ExpressionStatement":
walkExpressionStatement(node, visitors);
break;
case "ForInStatement":
walkForInStatement(node, visitors);
break;
case "ForOfStatement":
walkForOfStatement(node, visitors);
break;
case "ForStatement":
walkForStatement(node, visitors);
break;
case "FunctionDeclaration":
walkFunctionDeclaration(node, visitors);
break;
case "FunctionExpression":
walkFunctionExpression(node, visitors);
break;
case "Identifier":
walkIdentifier(node, visitors);
break;
case "IfStatement":
walkIfStatement(node, visitors);
break;
case "ImportAttribute":
walkImportAttribute(node, visitors);
break;
case "ImportDeclaration":
walkImportDeclaration(node, visitors);
break;
case "ImportDefaultSpecifier":
walkImportDefaultSpecifier(node, visitors);
break;
case "ImportExpression":
walkImportExpression(node, visitors);
break;
case "ImportNamespaceSpecifier":
walkImportNamespaceSpecifier(node, visitors);
break;
case "ImportSpecifier":
walkImportSpecifier(node, visitors);
break;
case "LabeledStatement":
walkLabeledStatement(node, visitors);
break;
case "LogicalExpression":
walkLogicalExpression(node, visitors);
break;
case "MemberExpression":
walkMemberExpression(node, visitors);
break;
case "MetaProperty":
walkMetaProperty(node, visitors);
break;
case "MethodDefinition":
walkMethodDefinition(node, visitors);
break;
case "NewExpression":
walkNewExpression(node, visitors);
break;
case "ObjectExpression":
walkObjectExpression(node, visitors);
break;
case "ObjectPattern":
walkObjectPattern(node, visitors);
break;
case "ParenthesizedExpression":
walkParenthesizedExpression(node, visitors);
break;
case "Program":
walkProgram(node, visitors);
break;
case "Property":
walkProperty(node, visitors);
break;
case "PropertyDefinition":
walkPropertyDefinition(node, visitors);
break;
case "RestElement":
walkRestElement(node, visitors);
break;
case "ReturnStatement":
walkReturnStatement(node, visitors);
break;
case "SequenceExpression":
walkSequenceExpression(node, visitors);
break;
case "SpreadElement":
walkSpreadElement(node, visitors);
break;
case "StaticBlock":
walkStaticBlock(node, visitors);
break;
case "SwitchCase":
walkSwitchCase(node, visitors);
break;
case "SwitchStatement":
walkSwitchStatement(node, visitors);
break;
case "TaggedTemplateExpression":
walkTaggedTemplateExpression(node, visitors);
break;
case "TemplateLiteral":
walkTemplateLiteral(node, visitors);
break;
case "ThrowStatement":
walkThrowStatement(node, visitors);
break;
case "TryStatement":
walkTryStatement(node, visitors);
break;
case "UnaryExpression":
walkUnaryExpression(node, visitors);
break;
case "UpdateExpression":
walkUpdateExpression(node, visitors);
break;
case "V8IntrinsicExpression":
walkV8IntrinsicExpression(node, visitors);
break;
case "VariableDeclaration":
walkVariableDeclaration(node, visitors);
break;
case "VariableDeclarator":
walkVariableDeclarator(node, visitors);
break;
case "WhileStatement":
walkWhileStatement(node, visitors);
break;
case "WithStatement":
walkWithStatement(node, visitors);
break;
case "YieldExpression":
walkYieldExpression(node, visitors);
break;
case "JSXAttribute":
walkJSXAttribute(node, visitors);
break;
case "JSXClosingElement":
walkJSXClosingElement(node, visitors);
break;
case "JSXElement":
walkJSXElement(node, visitors);
break;
case "JSXExpressionContainer":
walkJSXExpressionContainer(node, visitors);
break;
case "JSXFragment":
walkJSXFragment(node, visitors);
break;
case "JSXMemberExpression":
walkJSXMemberExpression(node, visitors);
break;
case "JSXNamespacedName":
walkJSXNamespacedName(node, visitors);
break;
case "JSXOpeningElement":
walkJSXOpeningElement(node, visitors);
break;
case "JSXSpreadAttribute":
walkJSXSpreadAttribute(node, visitors);
break;
case "JSXSpreadChild":
walkJSXSpreadChild(node, visitors);
break;
case "TSAbstractAccessorProperty":
walkTSAbstractAccessorProperty(node, visitors);
break;
case "TSAbstractMethodDefinition":
walkTSAbstractMethodDefinition(node, visitors);
break;
case "TSAbstractPropertyDefinition":
walkTSAbstractPropertyDefinition(node, visitors);
break;
case "TSArrayType":
walkTSArrayType(node, visitors);
break;
case "TSAsExpression":
walkTSAsExpression(node, visitors);
break;
case "TSCallSignatureDeclaration":
walkTSCallSignatureDeclaration(node, visitors);
break;
case "TSClassImplements":
walkTSClassImplements(node, visitors);
break;
case "TSConditionalType":
walkTSConditionalType(node, visitors);
break;
case "TSConstructSignatureDeclaration":
walkTSConstructSignatureDeclaration(node, visitors);
break;
case "TSConstructorType":
walkTSConstructorType(node, visitors);
break;
case "TSDeclareFunction":
walkTSDeclareFunction(node, visitors);
break;
case "TSEmptyBodyFunctionExpression":
walkTSEmptyBodyFunctionExpression(node, visitors);
break;
case "TSEnumBody":
walkTSEnumBody(node, visitors);
break;
case "TSEnumDeclaration":
walkTSEnumDeclaration(node, visitors);
break;
case "TSEnumMember":
walkTSEnumMember(node, visitors);
break;
case "TSExportAssignment":
walkTSExportAssignment(node, visitors);
break;
case "TSExternalModuleReference":
walkTSExternalModuleReference(node, visitors);
break;
case "TSFunctionType":
walkTSFunctionType(node, visitors);
break;
case "TSImportEqualsDeclaration":
walkTSImportEqualsDeclaration(node, visitors);
break;
case "TSImportType":
walkTSImportType(node, visitors);
break;
case "TSIndexSignature":
walkTSIndexSignature(node, visitors);
break;
case "TSIndexedAccessType":
walkTSIndexedAccessType(node, visitors);
break;
case "TSInferType":
walkTSInferType(node, visitors);
break;
case "TSInstantiationExpression":
walkTSInstantiationExpression(node, visitors);
break;
case "TSInterfaceBody":
walkTSInterfaceBody(node, visitors);
break;
case "TSInterfaceDeclaration":
walkTSInterfaceDeclaration(node, visitors);
break;
case "TSInterfaceHeritage":
walkTSInterfaceHeritage(node, visitors);
break;
case "TSIntersectionType":
walkTSIntersectionType(node, visitors);
break;
case "TSJSDocNonNullableType":
walkTSJSDocNonNullableType(node, visitors);
break;
case "TSJSDocNullableType":
walkTSJSDocNullableType(node, visitors);
break;
case "TSLiteralType":
walkTSLiteralType(node, visitors);
break;
case "TSMappedType":
walkTSMappedType(node, visitors);
break;
case "TSMethodSignature":
walkTSMethodSignature(node, visitors);
break;
case "TSModuleBlock":
walkTSModuleBlock(node, visitors);
break;
case "TSModuleDeclaration":
walkTSModuleDeclaration(node, visitors);
break;
case "TSNamedTupleMember":
walkTSNamedTupleMember(node, visitors);
break;
case "TSNamespaceExportDeclaration":
walkTSNamespaceExportDeclaration(node, visitors);
break;
case "TSNonNullExpression":
walkTSNonNullExpression(node, visitors);
break;
case "TSOptionalType":
walkTSOptionalType(node, visitors);
break;
case "TSParameterProperty":
walkTSParameterProperty(node, visitors);
break;
case "TSParenthesizedType":
walkTSParenthesizedType(node, visitors);
break;
case "TSPropertySignature":
walkTSPropertySignature(node, visitors);
break;
case "TSQualifiedName":
walkTSQualifiedName(node, visitors);
break;
case "TSRestType":
walkTSRestType(node, visitors);
break;
case "TSSatisfiesExpression":
walkTSSatisfiesExpression(node, visitors);
break;
case "TSTemplateLiteralType":
walkTSTemplateLiteralType(node, visitors);
break;
case "TSTupleType":
walkTSTupleType(node, visitors);
break;
case "TSTypeAliasDeclaration":
walkTSTypeAliasDeclaration(node, visitors);
break;
case "TSTypeAnnotation":
walkTSTypeAnnotation(node, visitors);
break;
case "TSTypeAssertion":
walkTSTypeAssertion(node, visitors);
break;
case "TSTypeLiteral":
walkTSTypeLiteral(node, visitors);
break;
case "TSTypeOperator":
walkTSTypeOperator(node, visitors);
break;
case "TSTypeParameter":
walkTSTypeParameter(node, visitors);
break;
case "TSTypeParameterDeclaration":
walkTSTypeParameterDeclaration(node, visitors);
break;
case "TSTypeParameterInstantiation":
walkTSTypeParameterInstantiation(node, visitors);
break;
case "TSTypePredicate":
walkTSTypePredicate(node, visitors);
break;
case "TSTypeQuery":
walkTSTypeQuery(node, visitors);
break;
case "TSTypeReference":
walkTSTypeReference(node, visitors);
break;
case "TSUnionType":
walkTSUnionType(node, visitors);
break;
}
}
function walkDebuggerStatement(node, visitors) {
let visit = visitors[0];
visit !== null && visit(node);
}
function walkEmptyStatement(node, visitors) {
let visit = visitors[1];
visit !== null && visit(node);
}
function walkLiteral(node, visitors) {
let visit = visitors[2];
visit !== null && visit(node);
}
function walkPrivateIdentifier(node, visitors) {
let visit = visitors[3];
visit !== null && visit(node);
}
function walkSuper(node, visitors) {
let visit = visitors[4];
visit !== null && visit(node);
}
function walkTemplateElement(node, visitors) {
let visit = visitors[5];
visit !== null && visit(node);
}
function walkThisExpression(node, visitors) {
let visit = visitors[6];
visit !== null && visit(node);
}
function walkJSXClosingFragment(node, visitors) {
let visit = visitors[7];
visit !== null && visit(node);
}
function walkJSXEmptyExpression(node, visitors) {
let visit = visitors[8];
visit !== null && visit(node);
}
function walkJSXIdentifier(node, visitors) {
let visit = visitors[9];
visit !== null && visit(node);
}
function walkJSXOpeningFragment(node, visitors) {
let visit = visitors[10];
visit !== null && visit(node);
}
function walkJSXText(node, visitors) {
let visit = visitors[11];
visit !== null && visit(node);
}
function walkTSAnyKeyword(node, visitors) {
let visit = visitors[12];
visit !== null && visit(node);
}
function walkTSBigIntKeyword(node, visitors) {
let visit = visitors[13];
visit !== null && visit(node);
}
function walkTSBooleanKeyword(node, visitors) {
let visit = visitors[14];
visit !== null && visit(node);
}
function walkTSIntrinsicKeyword(node, visitors) {
let visit = visitors[15];
visit !== null && visit(node);
}
function walkTSJSDocUnknownType(node, visitors) {
let visit = visitors[16];
visit !== null && visit(node);
}
function walkTSNeverKeyword(node, visitors) {
let visit = visitors[17];
visit !== null && visit(node);
}
function walkTSNullKeyword(node, visitors) {
let visit = visitors[18];
visit !== null && visit(node);
}
function walkTSNumberKeyword(node, visitors) {
let visit = visitors[19];
visit !== null && visit(node);
}
function walkTSObjectKeyword(node, visitors) {
let visit = visitors[20];
visit !== null && visit(node);
}
function walkTSStringKeyword(node, visitors) {
let visit = visitors[21];
visit !== null && visit(node);
}
function walkTSSymbolKeyword(node, visitors) {
let visit = visitors[22];
visit !== null && visit(node);
}
function walkTSThisType(node, visitors) {
let visit = visitors[23];
visit !== null && visit(node);
}
function walkTSUndefinedKeyword(node, visitors) {
let visit = visitors[24];
visit !== null && visit(node);
}
function walkTSUnknownKeyword(node, visitors) {
let visit = visitors[25];
visit !== null && visit(node);
}
function walkTSVoidKeyword(node, visitors) {
let visit = visitors[26];
visit !== null && visit(node);
}
function walkAccessorProperty(node, visitors) {
let enterExit = visitors[27], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.decorators, visitors);
walkNode(node.key, visitors);
walkNode(node.typeAnnotation, visitors);
walkNode(node.value, visitors);
exit !== null && exit(node);
}
function walkArrayExpression(node, visitors) {
let enterExit = visitors[28], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.elements, visitors);
exit !== null && exit(node);
}
function walkArrayPattern(node, visitors) {
let enterExit = visitors[29], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.decorators, visitors);
walkNode(node.elements, visitors);
walkNode(node.typeAnnotation, visitors);
exit !== null && exit(node);
}
function walkArrowFunctionExpression(node, visitors) {
let enterExit = visitors[30], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.typeParameters, visitors);
walkNode(node.params, visitors);
walkNode(node.returnType, visitors);
walkNode(node.body, visitors);
exit !== null && exit(node);
}
function walkAssignmentExpression(node, visitors) {
let enterExit = visitors[31], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.left, visitors);
walkNode(node.right, visitors);
exit !== null && exit(node);
}
function walkAssignmentPattern(node, visitors) {
let enterExit = visitors[32], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.decorators, visitors);
walkNode(node.left, visitors);
walkNode(node.right, visitors);
walkNode(node.typeAnnotation, visitors);
exit !== null && exit(node);
}
function walkAwaitExpression(node, visitors) {
let enterExit = visitors[33], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.argument, visitors);
exit !== null && exit(node);
}
function walkBinaryExpression(node, visitors) {
let enterExit = visitors[34], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.left, visitors);
walkNode(node.right, visitors);
exit !== null && exit(node);
}
function walkBlockStatement(node, visitors) {
let enterExit = visitors[35], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.body, visitors);
exit !== null && exit(node);
}
function walkBreakStatement(node, visitors) {
let enterExit = visitors[36], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.label, visitors);
exit !== null && exit(node);
}
function walkCallExpression(node, visitors) {
let enterExit = visitors[37], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.callee, visitors);
walkNode(node.typeArguments, visitors);
walkNode(node.arguments, visitors);
exit !== null && exit(node);
}
function walkCatchClause(node, visitors) {
let enterExit = visitors[38], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.param, visitors);
walkNode(node.body, visitors);
exit !== null && exit(node);
}
function walkChainExpression(node, visitors) {
let enterExit = visitors[39], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.expression, visitors);
exit !== null && exit(node);
}
function walkClassBody(node, visitors) {
let enterExit = visitors[40], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.body, visitors);
exit !== null && exit(node);
}
function walkClassDeclaration(node, visitors) {
let enterExit = visitors[41], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.decorators, visitors);
walkNode(node.id, visitors);
walkNode(node.typeParameters, visitors);
walkNode(node.superClass, visitors);
walkNode(node.superTypeArguments, visitors);
walkNode(node.implements, visitors);
walkNode(node.body, visitors);
exit !== null && exit(node);
}
function walkClassExpression(node, visitors) {
let enterExit = visitors[42], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.decorators, visitors);
walkNode(node.id, visitors);
walkNode(node.typeParameters, visitors);
walkNode(node.superClass, visitors);
walkNode(node.superTypeArguments, visitors);
walkNode(node.implements, visitors);
walkNode(node.body, visitors);
exit !== null && exit(node);
}
function walkConditionalExpression(node, visitors) {
let enterExit = visitors[43], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.test, visitors);
walkNode(node.consequent, visitors);
walkNode(node.alternate, visitors);
exit !== null && exit(node);
}
function walkContinueStatement(node, visitors) {
let enterExit = visitors[44], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.label, visitors);
exit !== null && exit(node);
}
function walkDecorator(node, visitors) {
let enterExit = visitors[45], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.expression, visitors);
exit !== null && exit(node);
}
function walkDoWhileStatement(node, visitors) {
let enterExit = visitors[46], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.body, visitors);
walkNode(node.test, visitors);
exit !== null && exit(node);
}
function walkExportAllDeclaration(node, visitors) {
let enterExit = visitors[47], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.exported, visitors);
walkNode(node.source, visitors);
walkNode(node.attributes, visitors);
exit !== null && exit(node);
}
function walkExportDefaultDeclaration(node, visitors) {
let enterExit = visitors[48], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.declaration, visitors);
exit !== null && exit(node);
}
function walkExportNamedDeclaration(node, visitors) {
let enterExit = visitors[49], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.declaration, visitors);
walkNode(node.specifiers, visitors);
walkNode(node.source, visitors);
walkNode(node.attributes, visitors);
exit !== null && exit(node);
}
function walkExportSpecifier(node, visitors) {
let enterExit = visitors[50], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.local, visitors);
walkNode(node.exported, visitors);
exit !== null && exit(node);
}
function walkExpressionStatement(node, visitors) {
let enterExit = visitors[51], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.expression, visitors);
exit !== null && exit(node);
}
function walkForInStatement(node, visitors) {
let enterExit = visitors[52], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.left, visitors);
walkNode(node.right, visitors);
walkNode(node.body, visitors);
exit !== null && exit(node);
}
function walkForOfStatement(node, visitors) {
let enterExit = visitors[53], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.left, visitors);
walkNode(node.right, visitors);
walkNode(node.body, visitors);
exit !== null && exit(node);
}
function walkForStatement(node, visitors) {
let enterExit = visitors[54], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.init, visitors);
walkNode(node.test, visitors);
walkNode(node.update, visitors);
walkNode(node.body, visitors);
exit !== null && exit(node);
}
function walkFunctionDeclaration(node, visitors) {
let enterExit = visitors[55], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.id, visitors);
walkNode(node.typeParameters, visitors);
walkNode(node.params, visitors);
walkNode(node.returnType, visitors);
walkNode(node.body, visitors);
exit !== null && exit(node);
}
function walkFunctionExpression(node, visitors) {
let enterExit = visitors[56], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.id, visitors);
walkNode(node.typeParameters, visitors);
walkNode(node.params, visitors);
walkNode(node.returnType, visitors);
walkNode(node.body, visitors);
exit !== null && exit(node);
}
function walkIdentifier(node, visitors) {
let enterExit = visitors[57], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.decorators, visitors);
walkNode(node.typeAnnotation, visitors);
exit !== null && exit(node);
}
function walkIfStatement(node, visitors) {
let enterExit = visitors[58], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.test, visitors);
walkNode(node.consequent, visitors);
walkNode(node.alternate, visitors);
exit !== null && exit(node);
}
function walkImportAttribute(node, visitors) {
let enterExit = visitors[59], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.key, visitors);
walkNode(node.value, visitors);
exit !== null && exit(node);
}
function walkImportDeclaration(node, visitors) {
let enterExit = visitors[60], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.specifiers, visitors);
walkNode(node.source, visitors);
walkNode(node.attributes, visitors);
exit !== null && exit(node);
}
function walkImportDefaultSpecifier(node, visitors) {
let enterExit = visitors[61], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.local, visitors);
exit !== null && exit(node);
}
function walkImportExpression(node, visitors) {
let enterExit = visitors[62], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.source, visitors);
walkNode(node.options, visitors);
exit !== null && exit(node);
}
function walkImportNamespaceSpecifier(node, visitors) {
let enterExit = visitors[63], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.local, visitors);
exit !== null && exit(node);
}
function walkImportSpecifier(node, visitors) {
let enterExit = visitors[64], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.imported, visitors);
walkNode(node.local, visitors);
exit !== null && exit(node);
}
function walkLabeledStatement(node, visitors) {
let enterExit = visitors[65], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.label, visitors);
walkNode(node.body, visitors);
exit !== null && exit(node);
}
function walkLogicalExpression(node, visitors) {
let enterExit = visitors[66], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.left, visitors);
walkNode(node.right, visitors);
exit !== null && exit(node);
}
function walkMemberExpression(node, visitors) {
let enterExit = visitors[67], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.object, visitors);
walkNode(node.property, visitors);
exit !== null && exit(node);
}
function walkMetaProperty(node, visitors) {
let enterExit = visitors[68], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.meta, visitors);
walkNode(node.property, visitors);
exit !== null && exit(node);
}
function walkMethodDefinition(node, visitors) {
let enterExit = visitors[69], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.decorators, visitors);
walkNode(node.key, visitors);
walkNode(node.value, visitors);
exit !== null && exit(node);
}
function walkNewExpression(node, visitors) {
let enterExit = visitors[70], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.callee, visitors);
walkNode(node.typeArguments, visitors);
walkNode(node.arguments, visitors);
exit !== null && exit(node);
}
function walkObjectExpression(node, visitors) {
let enterExit = visitors[71], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.properties, visitors);
exit !== null && exit(node);
}
function walkObjectPattern(node, visitors) {
let enterExit = visitors[72], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.decorators, visitors);
walkNode(node.properties, visitors);
walkNode(node.typeAnnotation, visitors);
exit !== null && exit(node);
}
function walkParenthesizedExpression(node, visitors) {
let enterExit = visitors[73], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.expression, visitors);
exit !== null && exit(node);
}
function walkProgram(node, visitors) {
let enterExit = visitors[74], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.body, visitors);
exit !== null && exit(node);
}
function walkProperty(node, visitors) {
let enterExit = visitors[75], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.key, visitors);
walkNode(node.value, visitors);
exit !== null && exit(node);
}
function walkPropertyDefinition(node, visitors) {
let enterExit = visitors[76], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.decorators, visitors);
walkNode(node.key, visitors);
walkNode(node.typeAnnotation, visitors);
walkNode(node.value, visitors);
exit !== null && exit(node);
}
function walkRestElement(node, visitors) {
let enterExit = visitors[77], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.decorators, visitors);
walkNode(node.argument, visitors);
walkNode(node.typeAnnotation, visitors);
exit !== null && exit(node);
}
function walkReturnStatement(node, visitors) {
let enterExit = visitors[78], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.argument, visitors);
exit !== null && exit(node);
}
function walkSequenceExpression(node, visitors) {
let enterExit = visitors[79], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.expressions, visitors);
exit !== null && exit(node);
}
function walkSpreadElement(node, visitors) {
let enterExit = visitors[80], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.argument, visitors);
exit !== null && exit(node);
}
function walkStaticBlock(node, visitors) {
let enterExit = visitors[81], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.body, visitors);
exit !== null && exit(node);
}
function walkSwitchCase(node, visitors) {
let enterExit = visitors[82], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.test, visitors);
walkNode(node.consequent, visitors);
exit !== null && exit(node);
}
function walkSwitchStatement(node, visitors) {
let enterExit = visitors[83], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.discriminant, visitors);
walkNode(node.cases, visitors);
exit !== null && exit(node);
}
function walkTaggedTemplateExpression(node, visitors) {
let enterExit = visitors[84], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.tag, visitors);
walkNode(node.typeArguments, visitors);
walkNode(node.quasi, visitors);
exit !== null && exit(node);
}
function walkTemplateLiteral(node, visitors) {
let enterExit = visitors[85], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.quasis, visitors);
walkNode(node.expressions, visitors);
exit !== null && exit(node);
}
function walkThrowStatement(node, visitors) {
let enterExit = visitors[86], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.argument, visitors);
exit !== null && exit(node);
}
function walkTryStatement(node, visitors) {
let enterExit = visitors[87], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.block, visitors);
walkNode(node.handler, visitors);
walkNode(node.finalizer, visitors);
exit !== null && exit(node);
}
function walkUnaryExpression(node, visitors) {
let enterExit = visitors[88], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.argument, visitors);
exit !== null && exit(node);
}
function walkUpdateExpression(node, visitors) {
let enterExit = visitors[89], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.argument, visitors);
exit !== null && exit(node);
}
function walkV8IntrinsicExpression(node, visitors) {
let enterExit = visitors[90], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.name, visitors);
walkNode(node.arguments, visitors);
exit !== null && exit(node);
}
function walkVariableDeclaration(node, visitors) {
let enterExit = visitors[91], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.declarations, visitors);
exit !== null && exit(node);
}
function walkVariableDeclarator(node, visitors) {
let enterExit = visitors[92], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.id, visitors);
walkNode(node.init, visitors);
exit !== null && exit(node);
}
function walkWhileStatement(node, visitors) {
let enterExit = visitors[93], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.test, visitors);
walkNode(node.body, visitors);
exit !== null && exit(node);
}
function walkWithStatement(node, visitors) {
let enterExit = visitors[94], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.object, visitors);
walkNode(node.body, visitors);
exit !== null && exit(node);
}
function walkYieldExpression(node, visitors) {
let enterExit = visitors[95], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.argument, visitors);
exit !== null && exit(node);
}
function walkJSXAttribute(node, visitors) {
let enterExit = visitors[96], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.name, visitors);
walkNode(node.value, visitors);
exit !== null && exit(node);
}
function walkJSXClosingElement(node, visitors) {
let enterExit = visitors[97], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.name, visitors);
exit !== null && exit(node);
}
function walkJSXElement(node, visitors) {
let enterExit = visitors[98], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.openingElement, visitors);
walkNode(node.children, visitors);
walkNode(node.closingElement, visitors);
exit !== null && exit(node);
}
function walkJSXExpressionContainer(node, visitors) {
let enterExit = visitors[99], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.expression, visitors);
exit !== null && exit(node);
}
function walkJSXFragment(node, visitors) {
let enterExit = visitors[100], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.openingFragment, visitors);
walkNode(node.children, visitors);
walkNode(node.closingFragment, visitors);
exit !== null && exit(node);
}
function walkJSXMemberExpression(node, visitors) {
let enterExit = visitors[101], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.object, visitors);
walkNode(node.property, visitors);
exit !== null && exit(node);
}
function walkJSXNamespacedName(node, visitors) {
let enterExit = visitors[102], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.namespace, visitors);
walkNode(node.name, visitors);
exit !== null && exit(node);
}
function walkJSXOpeningElement(node, visitors) {
let enterExit = visitors[103], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.name, visitors);
walkNode(node.typeArguments, visitors);
walkNode(node.attributes, visitors);
exit !== null && exit(node);
}
function walkJSXSpreadAttribute(node, visitors) {
let enterExit = visitors[104], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.argument, visitors);
exit !== null && exit(node);
}
function walkJSXSpreadChild(node, visitors) {
let enterExit = visitors[105], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.expression, visitors);
exit !== null && exit(node);
}
function walkTSAbstractAccessorProperty(node, visitors) {
let enterExit = visitors[106], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.decorators, visitors);
walkNode(node.key, visitors);
walkNode(node.typeAnnotation, visitors);
exit !== null && exit(node);
}
function walkTSAbstractMethodDefinition(node, visitors) {
let enterExit = visitors[107], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.key, visitors);
walkNode(node.value, visitors);
exit !== null && exit(node);
}
function walkTSAbstractPropertyDefinition(node, visitors) {
let enterExit = visitors[108], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.decorators, visitors);
walkNode(node.key, visitors);
walkNode(node.typeAnnotation, visitors);
exit !== null && exit(node);
}
function walkTSArrayType(node, visitors) {
let enterExit = visitors[109], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.elementType, visitors);
exit !== null && exit(node);
}
function walkTSAsExpression(node, visitors) {
let enterExit = visitors[110], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.expression, visitors);
walkNode(node.typeAnnotation, visitors);
exit !== null && exit(node);
}
function walkTSCallSignatureDeclaration(node, visitors) {
let enterExit = visitors[111], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.typeParameters, visitors);
walkNode(node.params, visitors);
walkNode(node.returnType, visitors);
exit !== null && exit(node);
}
function walkTSClassImplements(node, visitors) {
let enterExit = visitors[112], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.expression, visitors);
walkNode(node.typeArguments, visitors);
exit !== null && exit(node);
}
function walkTSConditionalType(node, visitors) {
let enterExit = visitors[113], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.checkType, visitors);
walkNode(node.extendsType, visitors);
walkNode(node.trueType, visitors);
walkNode(node.falseType, visitors);
exit !== null && exit(node);
}
function walkTSConstructSignatureDeclaration(node, visitors) {
let enterExit = visitors[114], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.typeParameters, visitors);
walkNode(node.params, visitors);
walkNode(node.returnType, visitors);
exit !== null && exit(node);
}
function walkTSConstructorType(node, visitors) {
let enterExit = visitors[115], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.typeParameters, visitors);
walkNode(node.params, visitors);
walkNode(node.returnType, visitors);
exit !== null && exit(node);
}
function walkTSDeclareFunction(node, visitors) {
let enterExit = visitors[116], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.id, visitors);
walkNode(node.typeParameters, visitors);
walkNode(node.params, visitors);
walkNode(node.returnType, visitors);
walkNode(node.body, visitors);
exit !== null && exit(node);
}
function walkTSEmptyBodyFunctionExpression(node, visitors) {
let enterExit = visitors[117], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.id, visitors);
walkNode(node.typeParameters, visitors);
walkNode(node.params, visitors);
walkNode(node.returnType, visitors);
exit !== null && exit(node);
}
function walkTSEnumBody(node, visitors) {
let enterExit = visitors[118], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.members, visitors);
exit !== null && exit(node);
}
function walkTSEnumDeclaration(node, visitors) {
let enterExit = visitors[119], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.id, visitors);
walkNode(node.body, visitors);
exit !== null && exit(node);
}
function walkTSEnumMember(node, visitors) {
let enterExit = visitors[120], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.id, visitors);
walkNode(node.initializer, visitors);
exit !== null && exit(node);
}
function walkTSExportAssignment(node, visitors) {
let enterExit = visitors[121], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.expression, visitors);
exit !== null && exit(node);
}
function walkTSExternalModuleReference(node, visitors) {
let enterExit = visitors[122], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.expression, visitors);
exit !== null && exit(node);
}
function walkTSFunctionType(node, visitors) {
let enterExit = visitors[123], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.typeParameters, visitors);
walkNode(node.params, visitors);
walkNode(node.returnType, visitors);
exit !== null && exit(node);
}
function walkTSImportEqualsDeclaration(node, visitors) {
let enterExit = visitors[124], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.id, visitors);
walkNode(node.moduleReference, visitors);
exit !== null && exit(node);
}
function walkTSImportType(node, visitors) {
let enterExit = visitors[125], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.source, visitors);
walkNode(node.options, visitors);
walkNode(node.qualifier, visitors);
walkNode(node.typeArguments, visitors);
exit !== null && exit(node);
}
function walkTSIndexSignature(node, visitors) {
let enterExit = visitors[126], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.parameters, visitors);
walkNode(node.typeAnnotation, visitors);
exit !== null && exit(node);
}
function walkTSIndexedAccessType(node, visitors) {
let enterExit = visitors[127], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.objectType, visitors);
walkNode(node.indexType, visitors);
exit !== null && exit(node);
}
function walkTSInferType(node, visitors) {
let enterExit = visitors[128], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.typeParameter, visitors);
exit !== null && exit(node);
}
function walkTSInstantiationExpression(node, visitors) {
let enterExit = visitors[129], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.expression, visitors);
walkNode(node.typeArguments, visitors);
exit !== null && exit(node);
}
function walkTSInterfaceBody(node, visitors) {
let enterExit = visitors[130], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.body, visitors);
exit !== null && exit(node);
}
function walkTSInterfaceDeclaration(node, visitors) {
let enterExit = visitors[131], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.id, visitors);
walkNode(node.typeParameters, visitors);
walkNode(node.extends, visitors);
walkNode(node.body, visitors);
exit !== null && exit(node);
}
function walkTSInterfaceHeritage(node, visitors) {
let enterExit = visitors[132], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.expression, visitors);
walkNode(node.typeArguments, visitors);
exit !== null && exit(node);
}
function walkTSIntersectionType(node, visitors) {
let enterExit = visitors[133], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.types, visitors);
exit !== null && exit(node);
}
function walkTSJSDocNonNullableType(node, visitors) {
let enterExit = visitors[134], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.typeAnnotation, visitors);
exit !== null && exit(node);
}
function walkTSJSDocNullableType(node, visitors) {
let enterExit = visitors[135], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.typeAnnotation, visitors);
exit !== null && exit(node);
}
function walkTSLiteralType(node, visitors) {
let enterExit = visitors[136], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.literal, visitors);
exit !== null && exit(node);
}
function walkTSMappedType(node, visitors) {
let enterExit = visitors[137], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.key, visitors);
walkNode(node.constraint, visitors);
walkNode(node.nameType, visitors);
walkNode(node.typeAnnotation, visitors);
exit !== null && exit(node);
}
function walkTSMethodSignature(node, visitors) {
let enterExit = visitors[138], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.key, visitors);
walkNode(node.typeParameters, visitors);
walkNode(node.params, visitors);
walkNode(node.returnType, visitors);
exit !== null && exit(node);
}
function walkTSModuleBlock(node, visitors) {
let enterExit = visitors[139], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.body, visitors);
exit !== null && exit(node);
}
function walkTSModuleDeclaration(node, visitors) {
let enterExit = visitors[140], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.id, visitors);
walkNode(node.body, visitors);
exit !== null && exit(node);
}
function walkTSNamedTupleMember(node, visitors) {
let enterExit = visitors[141], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.label, visitors);
walkNode(node.elementType, visitors);
exit !== null && exit(node);
}
function walkTSNamespaceExportDeclaration(node, visitors) {
let enterExit = visitors[142], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.id, visitors);
exit !== null && exit(node);
}
function walkTSNonNullExpression(node, visitors) {
let enterExit = visitors[143], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.expression, visitors);
exit !== null && exit(node);
}
function walkTSOptionalType(node, visitors) {
let enterExit = visitors[144], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.typeAnnotation, visitors);
exit !== null && exit(node);
}
function walkTSParameterProperty(node, visitors) {
let enterExit = visitors[145], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.decorators, visitors);
walkNode(node.parameter, visitors);
exit !== null && exit(node);
}
function walkTSParenthesizedType(node, visitors) {
let enterExit = visitors[146], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.typeAnnotation, visitors);
exit !== null && exit(node);
}
function walkTSPropertySignature(node, visitors) {
let enterExit = visitors[147], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.key, visitors);
walkNode(node.typeAnnotation, visitors);
exit !== null && exit(node);
}
function walkTSQualifiedName(node, visitors) {
let enterExit = visitors[148], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.left, visitors);
walkNode(node.right, visitors);
exit !== null && exit(node);
}
function walkTSRestType(node, visitors) {
let enterExit = visitors[149], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.typeAnnotation, visitors);
exit !== null && exit(node);
}
function walkTSSatisfiesExpression(node, visitors) {
let enterExit = visitors[150], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.expression, visitors);
walkNode(node.typeAnnotation, visitors);
exit !== null && exit(node);
}
function walkTSTemplateLiteralType(node, visitors) {
let enterExit = visitors[151], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.quasis, visitors);
walkNode(node.types, visitors);
exit !== null && exit(node);
}
function walkTSTupleType(node, visitors) {
let enterExit = visitors[152], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.elementTypes, visitors);
exit !== null && exit(node);
}
function walkTSTypeAliasDeclaration(node, visitors) {
let enterExit = visitors[153], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.id, visitors);
walkNode(node.typeParameters, visitors);
walkNode(node.typeAnnotation, visitors);
exit !== null && exit(node);
}
function walkTSTypeAnnotation(node, visitors) {
let enterExit = visitors[154], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.typeAnnotation, visitors);
exit !== null && exit(node);
}
function walkTSTypeAssertion(node, visitors) {
let enterExit = visitors[155], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.typeAnnotation, visitors);
walkNode(node.expression, visitors);
exit !== null && exit(node);
}
function walkTSTypeLiteral(node, visitors) {
let enterExit = visitors[156], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.members, visitors);
exit !== null && exit(node);
}
function walkTSTypeOperator(node, visitors) {
let enterExit = visitors[157], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.typeAnnotation, visitors);
exit !== null && exit(node);
}
function walkTSTypeParameter(node, visitors) {
let enterExit = visitors[158], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.name, visitors);
walkNode(node.constraint, visitors);
walkNode(node.default, visitors);
exit !== null && exit(node);
}
function walkTSTypeParameterDeclaration(node, visitors) {
let enterExit = visitors[159], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.params, visitors);
exit !== null && exit(node);
}
function walkTSTypeParameterInstantiation(node, visitors) {
let enterExit = visitors[160], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.params, visitors);
exit !== null && exit(node);
}
function walkTSTypePredicate(node, visitors) {
let enterExit = visitors[161], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.parameterName, visitors);
walkNode(node.typeAnnotation, visitors);
exit !== null && exit(node);
}
function walkTSTypeQuery(node, visitors) {
let enterExit = visitors[162], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.exprName, visitors);
walkNode(node.typeArguments, visitors);
exit !== null && exit(node);
}
function walkTSTypeReference(node, visitors) {
let enterExit = visitors[163], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.typeName, visitors);
walkNode(node.typeArguments, visitors);
exit !== null && exit(node);
}
function walkTSUnionType(node, visitors) {
let enterExit = visitors[164], exit = null, enter;
if (enterExit !== null) {
({enter, exit} = enterExit);
enter !== null && enter(node);
}
walkNode(node.types, visitors);
exit !== null && exit(node);
}
//#endregion
//#region ../../node_modules/.pnpm/oxc-parser@0.139.0/node_modules/oxc-parser/src-js/generated/visit/type_ids.js
/** Mapping from node type name to node type ID */
const NODE_TYPE_IDS_MAP = /* @__PURE__ */ new Map([
["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],
["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]
]);
//#endregion
//#region ../../node_modules/.pnpm/oxc-parser@0.139.0/node_modules/oxc-parser/src-js/visit/visitor.js
let compiledVisitor;
function createCompiledVisitor() {
compiledVisitor = [];
for (let i = 165; i !== 0; i--) compiledVisitor.push(null);
return compiledVisitor;
}
const mergedLeafVisitorTypeIds = [];
const mergedEnterVisitorTypeIds = [];
const mergedExitVisitorTypeIds = [];
for (let i = 27; i !== 0; i--) mergedLeafVisitorTypeIds.push(0);
for (let i = 138; i !== 0; i--) {
mergedEnterVisitorTypeIds.push(0);
mergedExitVisitorTypeIds.push(0);
}
mergedLeafVisitorTypeIds.length = 0;
mergedEnterVisitorTypeIds.length = 0;
mergedExitVisitorTypeIds.length = 0;
let hasActiveVisitors = false;
const enterExitObjectCache = [];
let enterExitObjectCacheNextIndex = 0;
function getEnterExitObject() {
if (enterExitObjectCacheNextIndex < enterExitObjectCache.length) return enterExitObjectCache[enterExitObjectCacheNextIndex++];
const enterExit = {
enter: null,
exit: null
};
enterExitObjectCache.push(enterExit);
enterExitObjectCacheNextIndex++;
return enterExit;
}
const visitFnArrayCache = [];
let visitFnArrayCacheNextIndex = 0;
function createVisitFnArray(visit1, visit2) {
if (visitFnArrayCacheNextIndex < visitFnArrayCache.length) {
const arr = visitFnArrayCache[visitFnArrayCacheNextIndex++];
arr.push(visit1, visit2);
return arr;
}
const arr = [visit1, visit2];
visitFnArrayCache.push(arr);
visitFnArrayCacheNextIndex++;
return arr;
}
/**
* Add a visitor to compiled visitor.
*
* @param visitor - Visitor object
*/
function addVisitorToCompiled(visitor) {
if (visitor === null || typeof visitor !== "object") throw new TypeError("Visitor must be an object");
const keys = Object.keys(visitor), keysLen = keys.length;
if (keysLen === 0) return;
hasActiveVisitors = true;
for (let i = 0; i < keysLen; i++) {
let name = keys[i];
const visitFn = visitor[name];
if (typeof visitFn !== "function") throw new TypeError(`'${name}' property of visitor object is not a function`);
const isExit = name.endsWith(":exit");
if (isExit) name = name.slice(0, -5);
const typeId = NODE_TYPE_IDS_MAP.get(name);
if (typeId === void 0) throw new Error(`Unknown node type '${name}' in visitor object`);
const existing = compiledVisitor[typeId];
if (typeId < 27) if (existing === null) compiledVisitor[typeId] = visitFn;
else if (Array.isArray(existing)) if (isExit) existing.push(visitFn);
else existing.splice(existing.length - 1, 0, visitFn);
else {
compiledVisitor[typeId] = isExit ? createVisitFnArray(existing, visitFn) : createVisitFnArray(visitFn, existing);
mergedLeafVisitorTypeIds.push(typeId);
}
else if (existing === null) {
const enterExit = compiledVisitor[typeId] = getEnterExitObject();
if (isExit) enterExit.exit = visitFn;
else enterExit.enter = visitFn;
} else if (isExit) {
const { exit } = existing;
if (exit === null) existing.exit = visitFn;
else if (Array.isArray(exit)) exit.push(visitFn);
else {
existing.exit = createVisitFnArray(exit, visitFn);
mergedExitVisitorTypeIds.push(typeId);
}
} else {
const { enter } = existing;
if (enter === null) existing.enter = visitFn;
else if (Array.isArray(enter)) enter.push(visitFn);
else {
existing.enter = createVisitFnArray(enter, visitFn);
mergedEnterVisitorTypeIds.push(typeId);
}
}
}
}
/**
* Finalize compiled visitor.
*
* After calling this function, `compiledVisitor` is ready to be used to walk the AST.
*
* @returns {boolean} - `true` if compiled visitor visits at least 1 AST type
*/
function finalizeCompiledVisitor() {
if (hasActiveVisitors === false) return false;
for (let i = mergedLeafVisitorTypeIds.length - 1; i >= 0; i--) {
const typeId = mergedLeafVisitorTypeIds[i];
compiledVisitor[typeId] = mergeVisitFns(compiledVisitor[typeId]);
}
for (let i = mergedEnterVisitorTypeIds.length - 1; i >= 0; i--) {
const typeId = mergedEnterVisitorTypeIds[i];
const enterExit = compiledVisitor[typeId];
enterExit.enter = mergeVisitFns(enterExit.enter);
}
for (let i = mergedExitVisitorTypeIds.length - 1; i >= 0; i--) {
const typeId = mergedExitVisitorTypeIds[i];
const enterExit = compiledVisitor[typeId];
enterExit.exit = mergeVisitFns(enterExit.exit);
}
mergedLeafVisitorTypeIds.length = 0;
mergedEnterVisitorTypeIds.length = 0;
mergedExitVisitorTypeIds.length = 0;
visitFnArrayCacheNextIndex = 0;
hasActiveVisitors = false;
return true;
}
/**
* Merge array of visit functions into a single function, which calls each of input functions in turn.
*
* The array passed is cleared (length set to 0), so the array can be reused.
*
* The merged function is statically defined and does not contain a loop, to hopefully allow
* JS engine to heavily optimize it.
*
* `mergers` contains pre-defined functions to merge up to 5 visit functions.
* Merger functions for merging more than 5 visit functions are created dynamically on demand.
*
* @param visitFns - Array of visit functions
* @returns Function which calls all of `visitFns` in turn.
*/
function mergeVisitFns(visitFns) {
const numVisitFns = visitFns.length;
let merger;
if (mergers.length <= numVisitFns) {
while (mergers.length < numVisitFns) mergers.push(null);
merger = createMerger(numVisitFns);
mergers.push(merger);
} else {
merger = mergers[numVisitFns];
if (merger === null) merger = mergers[numVisitFns] = createMerger(numVisitFns);
}
const mergedFn = merger(...visitFns);
visitFns.length = 0;
return mergedFn;
}
/**
* Create a merger function that merges `fnCount` functions.
*
* @param fnCount - Number of functions to be merged
* @returns Function to merge `fnCount` functions
*/
function createMerger(fnCount) {
const args = [];
let body = "return node=>{";
for (let i = 1; i <= fnCount; i++) {
args.push(`visit${i}`);
body += `visit${i}(node);`;
}
body += "}";
args.push(body);
return new Function(...args);
}
const mergers = [
null,
null,
(visit1, visit2) => (node) => {
visit1(node);
visit2(node);
},
(visit1, visit2, visit3) => (node) => {
visit1(node);
visit2(node);
visit3(node);
},
(visit1, visit2, visit3, visit4) => (node) => {
visit1(node);
visit2(node);
visit3(node);
visit4(node);
},
(visit1, visit2, visit3, visit4, visit5) => (node) => {
visit1(node);
visit2(node);
visit3(node);
visit4(node);
visit5(node);
}
];
//#endregion
//#region src/utils/visitor.ts
/**
* Visitor class for traversing AST.
*
* @example
* ```ts
* import { Visitor } from 'rolldown/utils';
* import { parseSync } from 'rolldown/utils';
*
* const result = parseSync(...);
* const visitor = new Visitor({
* VariableDeclaration(path) {
* // Do something with the variable declaration
* },
* "VariableDeclaration:exit"(path) {
* // Do something after visiting the variable declaration
* }
* });
* visitor.visit(result.program);
* ```
*
* @category Utilities
* @experimental
*/
var Visitor = class {
#compiledVisitor = null;
constructor(visitor) {
const compiledVisitor = createCompiledVisitor();
addVisitorToCompiled(visitor);
if (finalizeCompiledVisitor()) this.#compiledVisitor = compiledVisitor;
}
visit(program) {
const compiledVisitor = this.#compiledVisitor;
if (compiledVisitor !== null) walkProgram(program, compiledVisitor);
}
};
//#endregion
export { TsconfigCache, Visitor, minify, minifySync, parse, parseSync, transform, transformSync };