2417 lines
69 KiB
JavaScript
2417 lines
69 KiB
JavaScript
import "./shared/binding-BV_UWDF3.mjs";
|
|
import "./shared/error-BO4SlZV_.mjs";
|
|
import { n as parseSync, t as parse } from "./shared/parse-nWsWXhOL.mjs";
|
|
import { a as minify, i as transformSync, o as minifySync, r as transform, t as TsconfigCache } from "./shared/resolve-tsconfig-C3OzszY-.mjs";
|
|
//#region ../../node_modules/.pnpm/oxc-parser@0.120.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.120.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.120.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 };
|