mockaton 13.7.0 → 13.9.0

package/vite-plugin/node_modules/rolldown/dist/utils-index.mjs

@@ -0,0 +1,2414 @@
+import { n as parseSync, t as parse } from "./shared/parse-B_ZnWxLZ.mjs";
+import { a as minify, i as transformSync, o as minifySync, r as transform, t as TsconfigCache } from "./shared/resolve-tsconfig-CfYpGzid.mjs";
+//#region ../../node_modules/.pnpm/oxc-parser@0.127.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.127.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 = 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.127.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 = [], mergedEnterVisitorTypeIds = [], 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 };