@noodleseed/one 0.5.0 → 0.6.0

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

@@ -1,2414 +0,0 @@
-import { n as parseSync, t as parse } from "./shared/parse-CTgsjpo8.mjs";
-import { a as minify, i as transformSync, o as minifySync, r as transform, t as TsconfigCache } from "./shared/resolve-tsconfig-BkhP9bkX.mjs";
-//#region ../../node_modules/.pnpm/oxc-parser@0.137.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.137.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.137.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 };