frontend/node_modules/rolldown/dist/utils-index.mjs

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 };