File: /var/dev/shahnamag/back-end/node_modules/@swc/core/Visitor.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Visitor = void 0;
/**
* @deprecated JavaScript API is deprecated. Please use Wasm plugin instead.
*/
class Visitor {
visitProgram(n) {
switch (n.type) {
case "Module":
return this.visitModule(n);
case "Script":
return this.visitScript(n);
}
}
visitModule(m) {
m.body = this.visitModuleItems(m.body);
return m;
}
visitScript(m) {
m.body = this.visitStatements(m.body);
return m;
}
visitModuleItems(items) {
return items.map(this.visitModuleItem.bind(this));
}
visitModuleItem(n) {
switch (n.type) {
case "ExportDeclaration":
case "ExportDefaultDeclaration":
case "ExportNamedDeclaration":
case "ExportDefaultExpression":
case "ImportDeclaration":
case "ExportAllDeclaration":
case "TsImportEqualsDeclaration":
case "TsExportAssignment":
case "TsNamespaceExportDeclaration":
return this.visitModuleDeclaration(n);
default:
return this.visitStatement(n);
}
}
visitModuleDeclaration(n) {
switch (n.type) {
case "ExportDeclaration":
return this.visitExportDeclaration(n);
case "ExportDefaultDeclaration":
return this.visitExportDefaultDeclaration(n);
case "ExportNamedDeclaration":
return this.visitExportNamedDeclaration(n);
case "ExportDefaultExpression":
return this.visitExportDefaultExpression(n);
case "ImportDeclaration":
return this.visitImportDeclaration(n);
case "ExportAllDeclaration":
return this.visitExportAllDeclaration(n);
case "TsImportEqualsDeclaration":
return this.visitTsImportEqualsDeclaration(n);
case "TsExportAssignment":
return this.visitTsExportAssignment(n);
case "TsNamespaceExportDeclaration":
return this.visitTsNamespaceExportDeclaration(n);
}
}
visitTsNamespaceExportDeclaration(n) {
n.id = this.visitBindingIdentifier(n.id);
return n;
}
visitTsExportAssignment(n) {
n.expression = this.visitExpression(n.expression);
return n;
}
visitTsImportEqualsDeclaration(n) {
n.id = this.visitBindingIdentifier(n.id);
n.moduleRef = this.visitTsModuleReference(n.moduleRef);
return n;
}
visitTsModuleReference(n) {
switch (n.type) {
case "Identifier":
return this.visitIdentifierReference(n);
case "TsExternalModuleReference":
return this.visitTsExternalModuleReference(n);
case "TsQualifiedName":
return this.visitTsQualifiedName(n);
}
}
visitTsExternalModuleReference(n) {
n.expression = this.visitStringLiteral(n.expression);
return n;
}
visitExportAllDeclaration(n) {
n.source = this.visitStringLiteral(n.source);
return n;
}
visitExportDefaultExpression(n) {
n.expression = this.visitExpression(n.expression);
return n;
}
visitExportNamedDeclaration(n) {
n.specifiers = this.visitExportSpecifiers(n.specifiers);
n.source = this.visitOptionalStringLiteral(n.source);
return n;
}
visitExportSpecifiers(nodes) {
return nodes.map(this.visitExportSpecifier.bind(this));
}
visitExportSpecifier(n) {
switch (n.type) {
case "ExportDefaultSpecifier":
return this.visitExportDefaultSpecifier(n);
case "ExportNamespaceSpecifier":
return this.visitExportNamespaceSpecifier(n);
case "ExportSpecifier":
return this.visitNamedExportSpecifier(n);
}
}
visitNamedExportSpecifier(n) {
if (n.exported) {
n.exported = this.visitModuleExportName(n.exported);
}
n.orig = this.visitModuleExportName(n.orig);
return n;
}
visitModuleExportName(n) {
switch (n.type) {
case "Identifier":
return this.visitIdentifier(n);
case "StringLiteral":
return this.visitStringLiteral(n);
}
}
visitExportNamespaceSpecifier(n) {
n.name = this.visitModuleExportName(n.name);
return n;
}
visitExportDefaultSpecifier(n) {
n.exported = this.visitBindingIdentifier(n.exported);
return n;
}
visitOptionalStringLiteral(n) {
if (n) {
return this.visitStringLiteral(n);
}
}
visitExportDefaultDeclaration(n) {
n.decl = this.visitDefaultDeclaration(n.decl);
return n;
}
visitDefaultDeclaration(n) {
switch (n.type) {
case "ClassExpression":
return this.visitClassExpression(n);
case "FunctionExpression":
return this.visitFunctionExpression(n);
case "TsInterfaceDeclaration":
return this.visitTsInterfaceDeclaration(n);
}
}
visitFunctionExpression(n) {
n = this.visitFunction(n);
if (n.identifier) {
n.identifier = this.visitBindingIdentifier(n.identifier);
}
return n;
}
visitClassExpression(n) {
n = this.visitClass(n);
if (n.identifier) {
n.identifier = this.visitBindingIdentifier(n.identifier);
}
return n;
}
visitExportDeclaration(n) {
n.declaration = this.visitDeclaration(n.declaration);
return n;
}
visitArrayExpression(e) {
if (e.elements) {
e.elements = e.elements.map(this.visitArrayElement.bind(this));
}
return e;
}
visitArrayElement(e) {
if (e) {
return this.visitExprOrSpread(e);
}
}
visitExprOrSpread(e) {
return Object.assign(Object.assign({}, e), { expression: this.visitExpression(e.expression) });
}
visitExprOrSpreads(nodes) {
return nodes.map(this.visitExprOrSpread.bind(this));
}
visitSpreadElement(e) {
e.arguments = this.visitExpression(e.arguments);
return e;
}
visitOptionalExpression(e) {
if (e) {
return this.visitExpression(e);
}
}
visitArrowFunctionExpression(e) {
e.body = this.visitArrowBody(e.body);
e.params = this.visitPatterns(e.params);
e.returnType = this.visitTsTypeAnnotation(e.returnType);
e.typeParameters = this.visitTsTypeParameterDeclaration(e.typeParameters);
return e;
}
visitArrowBody(body) {
switch (body.type) {
case "BlockStatement":
return this.visitBlockStatement(body);
default:
return this.visitExpression(body);
}
}
visitBlockStatement(block) {
block.stmts = this.visitStatements(block.stmts);
return block;
}
visitStatements(stmts) {
return stmts.map(this.visitStatement.bind(this));
}
visitStatement(stmt) {
switch (stmt.type) {
case "ClassDeclaration":
case "FunctionDeclaration":
case "TsEnumDeclaration":
case "TsInterfaceDeclaration":
case "TsModuleDeclaration":
case "TsTypeAliasDeclaration":
case "VariableDeclaration":
return this.visitDeclaration(stmt);
case "BreakStatement":
return this.visitBreakStatement(stmt);
case "BlockStatement":
return this.visitBlockStatement(stmt);
case "ContinueStatement":
return this.visitContinueStatement(stmt);
case "DebuggerStatement":
return this.visitDebuggerStatement(stmt);
case "DoWhileStatement":
return this.visitDoWhileStatement(stmt);
case "EmptyStatement":
return this.visitEmptyStatement(stmt);
case "ForInStatement":
return this.visitForInStatement(stmt);
case "ForOfStatement":
return this.visitForOfStatement(stmt);
case "ForStatement":
return this.visitForStatement(stmt);
case "IfStatement":
return this.visitIfStatement(stmt);
case "LabeledStatement":
return this.visitLabeledStatement(stmt);
case "ReturnStatement":
return this.visitReturnStatement(stmt);
case "SwitchStatement":
return this.visitSwitchStatement(stmt);
case "ThrowStatement":
return this.visitThrowStatement(stmt);
case "TryStatement":
return this.visitTryStatement(stmt);
case "WhileStatement":
return this.visitWhileStatement(stmt);
case "WithStatement":
return this.visitWithStatement(stmt);
case "ExpressionStatement":
return this.visitExpressionStatement(stmt);
default:
throw new Error(`Unknown statement type: ` + stmt.type);
}
}
visitSwitchStatement(stmt) {
stmt.discriminant = this.visitExpression(stmt.discriminant);
stmt.cases = this.visitSwitchCases(stmt.cases);
return stmt;
}
visitSwitchCases(cases) {
return cases.map(this.visitSwitchCase.bind(this));
}
visitSwitchCase(c) {
c.test = this.visitOptionalExpression(c.test);
c.consequent = this.visitStatements(c.consequent);
return c;
}
visitIfStatement(stmt) {
stmt.test = this.visitExpression(stmt.test);
stmt.consequent = this.visitStatement(stmt.consequent);
stmt.alternate = this.visitOptionalStatement(stmt.alternate);
return stmt;
}
visitOptionalStatement(stmt) {
if (stmt) {
return this.visitStatement(stmt);
}
}
visitBreakStatement(stmt) {
if (stmt.label) {
stmt.label = this.visitLabelIdentifier(stmt.label);
}
return stmt;
}
visitWhileStatement(stmt) {
stmt.test = this.visitExpression(stmt.test);
stmt.body = this.visitStatement(stmt.body);
return stmt;
}
visitTryStatement(stmt) {
stmt.block = this.visitBlockStatement(stmt.block);
stmt.handler = this.visitCatchClause(stmt.handler);
if (stmt.finalizer) {
stmt.finalizer = this.visitBlockStatement(stmt.finalizer);
}
return stmt;
}
visitCatchClause(handler) {
if (handler) {
if (handler.param) {
handler.param = this.visitPattern(handler.param);
}
handler.body = this.visitBlockStatement(handler.body);
}
return handler;
}
visitThrowStatement(stmt) {
stmt.argument = this.visitExpression(stmt.argument);
return stmt;
}
visitReturnStatement(stmt) {
if (stmt.argument) {
stmt.argument = this.visitExpression(stmt.argument);
}
return stmt;
}
visitLabeledStatement(stmt) {
stmt.label = this.visitLabelIdentifier(stmt.label);
stmt.body = this.visitStatement(stmt.body);
return stmt;
}
visitForStatement(stmt) {
if (stmt.init) {
if (stmt.init.type === "VariableDeclaration") {
stmt.init = this.visitVariableDeclaration(stmt.init);
}
else {
stmt.init = this.visitOptionalExpression(stmt.init);
}
}
stmt.test = this.visitOptionalExpression(stmt.test);
stmt.update = this.visitOptionalExpression(stmt.update);
stmt.body = this.visitStatement(stmt.body);
return stmt;
}
visitForOfStatement(stmt) {
if (stmt.left.type === "VariableDeclaration") {
stmt.left = this.visitVariableDeclaration(stmt.left);
}
else {
stmt.left = this.visitPattern(stmt.left);
}
stmt.right = this.visitExpression(stmt.right);
stmt.body = this.visitStatement(stmt.body);
return stmt;
}
visitForInStatement(stmt) {
if (stmt.left.type === "VariableDeclaration") {
stmt.left = this.visitVariableDeclaration(stmt.left);
}
else {
stmt.left = this.visitPattern(stmt.left);
}
stmt.right = this.visitExpression(stmt.right);
stmt.body = this.visitStatement(stmt.body);
return stmt;
}
visitEmptyStatement(stmt) {
return stmt;
}
visitDoWhileStatement(stmt) {
stmt.body = this.visitStatement(stmt.body);
stmt.test = this.visitExpression(stmt.test);
return stmt;
}
visitDebuggerStatement(stmt) {
return stmt;
}
visitWithStatement(stmt) {
stmt.object = this.visitExpression(stmt.object);
stmt.body = this.visitStatement(stmt.body);
return stmt;
}
visitDeclaration(decl) {
switch (decl.type) {
case "ClassDeclaration":
return this.visitClassDeclaration(decl);
case "FunctionDeclaration":
return this.visitFunctionDeclaration(decl);
case "TsEnumDeclaration":
return this.visitTsEnumDeclaration(decl);
case "TsInterfaceDeclaration":
return this.visitTsInterfaceDeclaration(decl);
case "TsModuleDeclaration":
return this.visitTsModuleDeclaration(decl);
case "TsTypeAliasDeclaration":
return this.visitTsTypeAliasDeclaration(decl);
case "VariableDeclaration":
return this.visitVariableDeclaration(decl);
}
}
visitVariableDeclaration(n) {
n.declarations = this.visitVariableDeclarators(n.declarations);
return n;
}
visitVariableDeclarators(nodes) {
return nodes.map(this.visitVariableDeclarator.bind(this));
}
visitVariableDeclarator(n) {
n.id = this.visitPattern(n.id);
n.init = this.visitOptionalExpression(n.init);
return n;
}
visitTsTypeAliasDeclaration(n) {
n.id = this.visitBindingIdentifier(n.id);
n.typeAnnotation = this.visitTsType(n.typeAnnotation);
n.typeParams = this.visitTsTypeParameterDeclaration(n.typeParams);
return n;
}
visitTsModuleDeclaration(n) {
n.id = this.visitTsModuleName(n.id);
if (n.body) {
n.body = this.visitTsNamespaceBody(n.body);
}
return n;
}
visitTsModuleName(n) {
switch (n.type) {
case "Identifier":
return this.visitBindingIdentifier(n);
case "StringLiteral":
return this.visitStringLiteral(n);
}
}
visitTsNamespaceBody(n) {
if (n) {
switch (n.type) {
case "TsModuleBlock":
return this.visitTsModuleBlock(n);
case "TsNamespaceDeclaration":
return this.visitTsNamespaceDeclaration(n);
}
}
}
visitTsNamespaceDeclaration(n) {
const body = this.visitTsNamespaceBody(n.body);
if (body) {
n.body = body;
}
n.id = this.visitBindingIdentifier(n.id);
return n;
}
visitTsModuleBlock(n) {
n.body = this.visitModuleItems(n.body);
return n;
}
visitTsInterfaceDeclaration(n) {
n.id = this.visitBindingIdentifier(n.id);
n.typeParams = this.visitTsTypeParameterDeclaration(n.typeParams);
n.extends = this.visitTsExpressionsWithTypeArguments(n.extends);
n.body = this.visitTsInterfaceBody(n.body);
return n;
}
visitTsInterfaceBody(n) {
n.body = this.visitTsTypeElements(n.body);
return n;
}
visitTsTypeElements(nodes) {
return nodes.map(this.visitTsTypeElement.bind(this));
}
visitTsTypeElement(n) {
switch (n.type) {
case "TsCallSignatureDeclaration":
return this.visitTsCallSignatureDeclaration(n);
case "TsConstructSignatureDeclaration":
return this.visitTsConstructSignatureDeclaration(n);
case "TsPropertySignature":
return this.visitTsPropertySignature(n);
case "TsGetterSignature":
return this.visitTsGetterSignature(n);
case "TsSetterSignature":
return this.visitTsSetterSignature(n);
case "TsMethodSignature":
return this.visitTsMethodSignature(n);
case "TsIndexSignature":
return this.visitTsIndexSignature(n);
}
}
visitTsCallSignatureDeclaration(n) {
n.params = this.visitTsFnParameters(n.params);
n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
return n;
}
visitTsConstructSignatureDeclaration(n) {
n.params = this.visitTsFnParameters(n.params);
n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
return n;
}
visitTsPropertySignature(n) {
n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
return n;
}
visitTsGetterSignature(n) {
n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
return n;
}
visitTsSetterSignature(n) {
n.param = this.visitTsFnParameter(n.param);
return n;
}
visitTsMethodSignature(n) {
n.params = this.visitTsFnParameters(n.params);
n.typeAnn = this.visitTsTypeAnnotation(n.typeAnn);
return n;
}
visitTsEnumDeclaration(n) {
n.id = this.visitIdentifier(n.id);
n.members = this.visitTsEnumMembers(n.members);
return n;
}
visitTsEnumMembers(nodes) {
return nodes.map(this.visitTsEnumMember.bind(this));
}
visitTsEnumMember(n) {
n.id = this.visitTsEnumMemberId(n.id);
n.init = this.visitOptionalExpression(n.init);
return n;
}
visitTsEnumMemberId(n) {
switch (n.type) {
case "Identifier":
return this.visitBindingIdentifier(n);
case "StringLiteral":
return this.visitStringLiteral(n);
}
}
visitFunctionDeclaration(decl) {
decl.identifier = this.visitIdentifier(decl.identifier);
decl = this.visitFunction(decl);
return decl;
}
visitClassDeclaration(decl) {
decl = this.visitClass(decl);
decl.identifier = this.visitIdentifier(decl.identifier);
return decl;
}
visitClassBody(members) {
return members.map(this.visitClassMember.bind(this));
}
visitClassMember(member) {
switch (member.type) {
case "ClassMethod":
return this.visitClassMethod(member);
case "ClassProperty":
return this.visitClassProperty(member);
case "Constructor":
return this.visitConstructor(member);
case "PrivateMethod":
return this.visitPrivateMethod(member);
case "PrivateProperty":
return this.visitPrivateProperty(member);
case "TsIndexSignature":
return this.visitTsIndexSignature(member);
case "EmptyStatement":
return this.visitEmptyStatement(member);
case "StaticBlock":
return this.visitStaticBlock(member);
}
}
visitTsIndexSignature(n) {
n.params = this.visitTsFnParameters(n.params);
if (n.typeAnnotation)
n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
return n;
}
visitTsFnParameters(params) {
return params.map(this.visitTsFnParameter.bind(this));
}
visitTsFnParameter(n) {
n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
return n;
}
visitPrivateProperty(n) {
n.decorators = this.visitDecorators(n.decorators);
n.key = this.visitPrivateName(n.key);
n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
n.value = this.visitOptionalExpression(n.value);
return n;
}
visitPrivateMethod(n) {
n.accessibility = this.visitAccessibility(n.accessibility);
n.function = this.visitFunction(n.function);
n.key = this.visitPrivateName(n.key);
return n;
}
visitPrivateName(n) {
return n;
}
visitConstructor(n) {
n.accessibility = this.visitAccessibility(n.accessibility);
n.key = this.visitPropertyName(n.key);
n.params = this.visitConstructorParameters(n.params);
if (n.body) {
n.body = this.visitBlockStatement(n.body);
}
return n;
}
visitConstructorParameters(nodes) {
return nodes.map(this.visitConstructorParameter.bind(this));
}
visitConstructorParameter(n) {
switch (n.type) {
case "TsParameterProperty":
return this.visitTsParameterProperty(n);
default:
return this.visitParameter(n);
}
}
visitStaticBlock(n) {
n.body = this.visitBlockStatement(n.body);
return n;
}
visitTsParameterProperty(n) {
n.accessibility = this.visitAccessibility(n.accessibility);
n.decorators = this.visitDecorators(n.decorators);
n.param = this.visitTsParameterPropertyParameter(n.param);
return n;
}
visitTsParameterPropertyParameter(n) {
n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
return n;
}
visitPropertyName(key) {
switch (key.type) {
case "Identifier":
return this.visitBindingIdentifier(key);
case "StringLiteral":
return this.visitStringLiteral(key);
case "NumericLiteral":
return this.visitNumericLiteral(key);
case "BigIntLiteral":
return this.visitBigIntLiteral(key);
default:
return this.visitComputedPropertyKey(key);
}
}
visitAccessibility(n) {
return n;
}
visitClassProperty(n) {
n.accessibility = this.visitAccessibility(n.accessibility);
n.decorators = this.visitDecorators(n.decorators);
n.key = this.visitPropertyName(n.key);
n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
n.value = this.visitOptionalExpression(n.value);
return n;
}
visitClassMethod(n) {
n.accessibility = this.visitAccessibility(n.accessibility);
n.function = this.visitFunction(n.function);
n.key = this.visitPropertyName(n.key);
return n;
}
visitComputedPropertyKey(n) {
n.expression = this.visitExpression(n.expression);
return n;
}
visitClass(n) {
n.decorators = this.visitDecorators(n.decorators);
n.superClass = this.visitOptionalExpression(n.superClass);
n.superTypeParams = this.visitTsTypeParameterInstantiation(n.superTypeParams);
if (n.implements) {
n.implements = this.visitTsExpressionsWithTypeArguments(n.implements);
}
n.body = this.visitClassBody(n.body);
return n;
}
visitFunction(n) {
n.decorators = this.visitDecorators(n.decorators);
n.params = this.visitParameters(n.params);
if (n.body) {
n.body = this.visitBlockStatement(n.body);
}
n.returnType = this.visitTsTypeAnnotation(n.returnType);
n.typeParameters = this.visitTsTypeParameterDeclaration(n.typeParameters);
return n;
}
visitTsExpressionsWithTypeArguments(nodes) {
return nodes.map(this.visitTsExpressionWithTypeArguments.bind(this));
}
visitTsExpressionWithTypeArguments(n) {
n.expression = this.visitExpression(n.expression);
n.typeArguments = this.visitTsTypeParameterInstantiation(n.typeArguments);
return n;
}
visitTsTypeParameterInstantiation(n) {
if (n) {
n.params = this.visitTsTypes(n.params);
}
return n;
}
visitTsTypes(nodes) {
return nodes.map(this.visitTsType.bind(this));
}
visitTsEntityName(n) {
switch (n.type) {
case "Identifier":
return this.visitBindingIdentifier(n);
case "TsQualifiedName":
return this.visitTsQualifiedName(n);
}
}
visitTsQualifiedName(n) {
n.left = this.visitTsEntityName(n.left);
n.right = this.visitIdentifier(n.right);
return n;
}
visitDecorators(nodes) {
if (nodes) {
return nodes.map(this.visitDecorator.bind(this));
}
}
visitDecorator(n) {
n.expression = this.visitExpression(n.expression);
return n;
}
visitExpressionStatement(stmt) {
stmt.expression = this.visitExpression(stmt.expression);
return stmt;
}
visitContinueStatement(stmt) {
if (stmt.label) {
stmt.label = this.visitLabelIdentifier(stmt.label);
}
return stmt;
}
visitExpression(n) {
switch (n.type) {
case "ArrayExpression":
return this.visitArrayExpression(n);
case "ArrowFunctionExpression":
return this.visitArrowFunctionExpression(n);
case "AssignmentExpression":
return this.visitAssignmentExpression(n);
case "AwaitExpression":
return this.visitAwaitExpression(n);
case "BigIntLiteral":
return this.visitBigIntLiteral(n);
case "BinaryExpression":
return this.visitBinaryExpression(n);
case "BooleanLiteral":
return this.visitBooleanLiteral(n);
case "CallExpression":
return this.visitCallExpression(n);
case "ClassExpression":
return this.visitClassExpression(n);
case "ConditionalExpression":
return this.visitConditionalExpression(n);
case "FunctionExpression":
return this.visitFunctionExpression(n);
case "Identifier":
return this.visitIdentifierReference(n);
case "JSXElement":
return this.visitJSXElement(n);
case "JSXEmptyExpression":
return this.visitJSXEmptyExpression(n);
case "JSXFragment":
return this.visitJSXFragment(n);
case "JSXMemberExpression":
return this.visitJSXMemberExpression(n);
case "JSXNamespacedName":
return this.visitJSXNamespacedName(n);
case "JSXText":
return this.visitJSXText(n);
case "MemberExpression":
return this.visitMemberExpression(n);
case "SuperPropExpression":
return this.visitSuperPropExpression(n);
case "MetaProperty":
return this.visitMetaProperty(n);
case "NewExpression":
return this.visitNewExpression(n);
case "NullLiteral":
return this.visitNullLiteral(n);
case "NumericLiteral":
return this.visitNumericLiteral(n);
case "ObjectExpression":
return this.visitObjectExpression(n);
case "ParenthesisExpression":
return this.visitParenthesisExpression(n);
case "PrivateName":
return this.visitPrivateName(n);
case "RegExpLiteral":
return this.visitRegExpLiteral(n);
case "SequenceExpression":
return this.visitSequenceExpression(n);
case "StringLiteral":
return this.visitStringLiteral(n);
case "TaggedTemplateExpression":
return this.visitTaggedTemplateExpression(n);
case "TemplateLiteral":
return this.visitTemplateLiteral(n);
case "ThisExpression":
return this.visitThisExpression(n);
case "TsAsExpression":
return this.visitTsAsExpression(n);
case "TsSatisfiesExpression":
return this.visitTsSatisfiesExpression(n);
case "TsNonNullExpression":
return this.visitTsNonNullExpression(n);
case "TsTypeAssertion":
return this.visitTsTypeAssertion(n);
case "TsConstAssertion":
return this.visitTsConstAssertion(n);
case "TsInstantiation":
return this.visitTsInstantiation(n);
case "UnaryExpression":
return this.visitUnaryExpression(n);
case "UpdateExpression":
return this.visitUpdateExpression(n);
case "YieldExpression":
return this.visitYieldExpression(n);
case "OptionalChainingExpression":
return this.visitOptionalChainingExpression(n);
case "Invalid":
return n;
}
}
visitOptionalChainingExpression(n) {
n.base = this.visitMemberExpressionOrOptionalChainingCall(n.base);
return n;
}
visitMemberExpressionOrOptionalChainingCall(n) {
switch (n.type) {
case "MemberExpression":
return this.visitMemberExpression(n);
case "CallExpression":
return this.visitOptionalChainingCall(n);
}
}
visitOptionalChainingCall(n) {
n.callee = this.visitExpression(n.callee);
n.arguments = this.visitExprOrSpreads(n.arguments);
if (n.typeArguments)
n.typeArguments = this.visitTsTypeParameterInstantiation(n.typeArguments);
return n;
}
visitAssignmentExpression(n) {
n.left = this.visitPatternOrExpression(n.left);
n.right = this.visitExpression(n.right);
return n;
}
visitPatternOrExpression(n) {
switch (n.type) {
case "ObjectPattern":
case "ArrayPattern":
case "Identifier":
case "AssignmentPattern":
case "RestElement":
return this.visitPattern(n);
default:
return this.visitExpression(n);
}
}
visitYieldExpression(n) {
n.argument = this.visitOptionalExpression(n.argument);
return n;
}
visitUpdateExpression(n) {
n.argument = this.visitExpression(n.argument);
return n;
}
visitUnaryExpression(n) {
n.argument = this.visitExpression(n.argument);
return n;
}
visitTsTypeAssertion(n) {
n.expression = this.visitExpression(n.expression);
n.typeAnnotation = this.visitTsType(n.typeAnnotation);
return n;
}
visitTsConstAssertion(n) {
n.expression = this.visitExpression(n.expression);
return n;
}
visitTsInstantiation(n) {
n.expression = this.visitExpression(n.expression);
return n;
}
visitTsNonNullExpression(n) {
n.expression = this.visitExpression(n.expression);
return n;
}
visitTsAsExpression(n) {
n.expression = this.visitExpression(n.expression);
n.typeAnnotation = this.visitTsType(n.typeAnnotation);
return n;
}
visitTsSatisfiesExpression(n) {
n.expression = this.visitExpression(n.expression);
n.typeAnnotation = this.visitTsType(n.typeAnnotation);
return n;
}
visitThisExpression(n) {
return n;
}
visitTemplateLiteral(n) {
n.expressions = n.expressions.map(this.visitExpression.bind(this));
return n;
}
visitParameters(n) {
return n.map(this.visitParameter.bind(this));
}
visitParameter(n) {
n.pat = this.visitPattern(n.pat);
return n;
}
visitTaggedTemplateExpression(n) {
n.tag = this.visitExpression(n.tag);
const template = this.visitTemplateLiteral(n.template);
if (template.type === "TemplateLiteral") {
n.template = template;
}
return n;
}
visitSequenceExpression(n) {
n.expressions = n.expressions.map(this.visitExpression.bind(this));
return n;
}
visitRegExpLiteral(n) {
return n;
}
visitParenthesisExpression(n) {
n.expression = this.visitExpression(n.expression);
return n;
}
visitObjectExpression(n) {
if (n.properties) {
n.properties = this.visitObjectProperties(n.properties);
}
return n;
}
visitObjectProperties(nodes) {
return nodes.map(this.visitObjectProperty.bind(this));
}
visitObjectProperty(n) {
switch (n.type) {
case "SpreadElement":
return this.visitSpreadElement(n);
default:
return this.visitProperty(n);
}
}
visitProperty(n) {
switch (n.type) {
case "Identifier":
return this.visitIdentifier(n);
case "AssignmentProperty":
return this.visitAssignmentProperty(n);
case "GetterProperty":
return this.visitGetterProperty(n);
case "KeyValueProperty":
return this.visitKeyValueProperty(n);
case "MethodProperty":
return this.visitMethodProperty(n);
case "SetterProperty":
return this.visitSetterProperty(n);
}
}
visitSetterProperty(n) {
n.key = this.visitPropertyName(n.key);
n.param = this.visitPattern(n.param);
if (n.body) {
n.body = this.visitBlockStatement(n.body);
}
return n;
}
visitMethodProperty(n) {
n.key = this.visitPropertyName(n.key);
if (n.body) {
n.body = this.visitBlockStatement(n.body);
}
n.decorators = this.visitDecorators(n.decorators);
n.params = this.visitParameters(n.params);
n.returnType = this.visitTsTypeAnnotation(n.returnType);
n.typeParameters = this.visitTsTypeParameterDeclaration(n.typeParameters);
return n;
}
visitKeyValueProperty(n) {
n.key = this.visitPropertyName(n.key);
n.value = this.visitExpression(n.value);
return n;
}
visitGetterProperty(n) {
n.key = this.visitPropertyName(n.key);
if (n.body) {
n.body = this.visitBlockStatement(n.body);
}
n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
return n;
}
visitAssignmentProperty(n) {
n.key = this.visitIdentifier(n.key);
n.value = this.visitExpression(n.value);
return n;
}
visitNullLiteral(n) {
return n;
}
visitNewExpression(n) {
n.callee = this.visitExpression(n.callee);
if (n.arguments) {
n.arguments = this.visitArguments(n.arguments);
}
n.typeArguments = this.visitTsTypeArguments(n.typeArguments);
return n;
}
visitTsTypeArguments(n) {
if (n) {
n.params = this.visitTsTypes(n.params);
}
return n;
}
visitArguments(nodes) {
return nodes.map(this.visitArgument.bind(this));
}
visitArgument(n) {
n.expression = this.visitExpression(n.expression);
return n;
}
visitMetaProperty(n) {
return n;
}
visitMemberExpression(n) {
n.object = this.visitExpression(n.object);
switch (n.property.type) {
case "Computed": {
n.property = this.visitComputedPropertyKey(n.property);
return n;
}
case "Identifier": {
n.property = this.visitIdentifier(n.property);
return n;
}
case "PrivateName": {
n.property = this.visitPrivateName(n.property);
return n;
}
}
}
visitSuperPropExpression(n) {
switch (n.property.type) {
case "Computed": {
n.property = this.visitComputedPropertyKey(n.property);
return n;
}
case "Identifier": {
n.property = this.visitIdentifier(n.property);
return n;
}
}
}
visitCallee(n) {
if (n.type === "Super" || n.type === "Import") {
return n;
}
return this.visitExpression(n);
}
visitJSXText(n) {
return n;
}
visitJSXNamespacedName(n) {
n.namespace = this.visitIdentifierReference(n.namespace);
n.name = this.visitIdentifierReference(n.name);
return n;
}
visitJSXMemberExpression(n) {
n.object = this.visitJSXObject(n.object);
n.property = this.visitIdentifierReference(n.property);
return n;
}
visitJSXObject(n) {
switch (n.type) {
case "Identifier":
return this.visitIdentifierReference(n);
case "JSXMemberExpression":
return this.visitJSXMemberExpression(n);
}
}
visitJSXFragment(n) {
n.opening = this.visitJSXOpeningFragment(n.opening);
if (n.children) {
n.children = this.visitJSXElementChildren(n.children);
}
n.closing = this.visitJSXClosingFragment(n.closing);
return n;
}
visitJSXClosingFragment(n) {
return n;
}
visitJSXElementChildren(nodes) {
return nodes.map(this.visitJSXElementChild.bind(this));
}
visitJSXElementChild(n) {
switch (n.type) {
case "JSXElement":
return this.visitJSXElement(n);
case "JSXExpressionContainer":
return this.visitJSXExpressionContainer(n);
case "JSXFragment":
return this.visitJSXFragment(n);
case "JSXSpreadChild":
return this.visitJSXSpreadChild(n);
case "JSXText":
return this.visitJSXText(n);
}
}
visitJSXExpressionContainer(n) {
n.expression = this.visitExpression(n.expression);
return n;
}
visitJSXSpreadChild(n) {
n.expression = this.visitExpression(n.expression);
return n;
}
visitJSXOpeningFragment(n) {
return n;
}
visitJSXEmptyExpression(n) {
return n;
}
visitJSXElement(n) {
n.opening = this.visitJSXOpeningElement(n.opening);
n.children = this.visitJSXElementChildren(n.children);
n.closing = this.visitJSXClosingElement(n.closing);
return n;
}
visitJSXClosingElement(n) {
if (n) {
n.name = this.visitJSXElementName(n.name);
}
return n;
}
visitJSXElementName(n) {
switch (n.type) {
case "Identifier":
return this.visitIdentifierReference(n);
case "JSXMemberExpression":
return this.visitJSXMemberExpression(n);
case "JSXNamespacedName":
return this.visitJSXNamespacedName(n);
}
}
visitJSXOpeningElement(n) {
n.name = this.visitJSXElementName(n.name);
n.typeArguments = this.visitTsTypeParameterInstantiation(n.typeArguments);
n.attributes = this.visitJSXAttributeOrSpreads(n.attributes);
return n;
}
visitJSXAttributes(attrs) {
if (attrs)
return attrs.map(this.visitJSXAttributeOrSpread.bind(this));
}
visitJSXAttributeOrSpread(n) {
switch (n.type) {
case "JSXAttribute":
return this.visitJSXAttribute(n);
case "SpreadElement":
return this.visitSpreadElement(n);
}
}
visitJSXAttributeOrSpreads(nodes) {
return nodes.map(this.visitJSXAttributeOrSpread.bind(this));
}
visitJSXAttribute(n) {
n.name = this.visitJSXAttributeName(n.name);
n.value = this.visitJSXAttributeValue(n.value);
return n;
}
visitJSXAttributeValue(n) {
if (!n)
return n;
switch (n.type) {
case "BooleanLiteral":
return this.visitBooleanLiteral(n);
case "NullLiteral":
return this.visitNullLiteral(n);
case "NumericLiteral":
return this.visitNumericLiteral(n);
case "JSXText":
return this.visitJSXText(n);
case "StringLiteral":
return this.visitStringLiteral(n);
case "JSXElement":
return this.visitJSXElement(n);
case "JSXExpressionContainer":
return this.visitJSXExpressionContainer(n);
case "JSXFragment":
return this.visitJSXFragment(n);
}
return n;
}
visitJSXAttributeName(n) {
switch (n.type) {
case "Identifier":
return this.visitIdentifierReference(n);
case "JSXNamespacedName":
return this.visitJSXNamespacedName(n);
}
}
visitConditionalExpression(n) {
n.test = this.visitExpression(n.test);
n.consequent = this.visitExpression(n.consequent);
n.alternate = this.visitExpression(n.alternate);
return n;
}
visitCallExpression(n) {
n.callee = this.visitCallee(n.callee);
n.typeArguments = this.visitTsTypeParameterInstantiation(n.typeArguments);
if (n.arguments) {
n.arguments = this.visitArguments(n.arguments);
}
return n;
}
visitBooleanLiteral(n) {
return n;
}
visitBinaryExpression(n) {
n.left = this.visitExpression(n.left);
n.right = this.visitExpression(n.right);
return n;
}
visitAwaitExpression(n) {
n.argument = this.visitExpression(n.argument);
return n;
}
visitTsTypeParameterDeclaration(n) {
if (n) {
n.parameters = this.visitTsTypeParameters(n.parameters);
}
return n;
}
visitTsTypeParameters(nodes) {
return nodes.map(this.visitTsTypeParameter.bind(this));
}
visitTsTypeParameter(n) {
if (n.constraint) {
n.constraint = this.visitTsType(n.constraint);
}
if (n.default) {
n.default = this.visitTsType(n.default);
}
n.name = this.visitIdentifierReference(n.name);
return n;
}
visitTsTypeAnnotation(a) {
if (a) {
a.typeAnnotation = this.visitTsType(a.typeAnnotation);
}
return a;
}
visitTsType(n) {
throw new Error("Method visitTsType not implemented.");
}
visitPatterns(nodes) {
return nodes.map(this.visitPattern.bind(this));
}
visitImportDeclaration(n) {
n.source = this.visitStringLiteral(n.source);
n.specifiers = this.visitImportSpecifiers(n.specifiers || []);
return n;
}
visitImportSpecifiers(nodes) {
return nodes.map(this.visitImportSpecifier.bind(this));
}
visitImportSpecifier(node) {
switch (node.type) {
case "ImportDefaultSpecifier":
return this.visitImportDefaultSpecifier(node);
case "ImportNamespaceSpecifier":
return this.visitImportNamespaceSpecifier(node);
case "ImportSpecifier":
return this.visitNamedImportSpecifier(node);
}
}
visitNamedImportSpecifier(node) {
node.local = this.visitBindingIdentifier(node.local);
if (node.imported) {
node.imported = this.visitModuleExportName(node.imported);
}
return node;
}
visitImportNamespaceSpecifier(node) {
node.local = this.visitBindingIdentifier(node.local);
return node;
}
visitImportDefaultSpecifier(node) {
node.local = this.visitBindingIdentifier(node.local);
return node;
}
visitBindingIdentifier(i) {
if (i.typeAnnotation) {
i.typeAnnotation = this.visitTsTypeAnnotation(i.typeAnnotation);
}
return this.visitIdentifier(i);
}
visitIdentifierReference(i) {
return this.visitIdentifier(i);
}
visitLabelIdentifier(label) {
return this.visitIdentifier(label);
}
visitIdentifier(n) {
return n;
}
visitStringLiteral(n) {
return n;
}
visitNumericLiteral(n) {
return n;
}
visitBigIntLiteral(n) {
return n;
}
visitPattern(n) {
switch (n.type) {
case "Identifier":
return this.visitBindingIdentifier(n);
case "ArrayPattern":
return this.visitArrayPattern(n);
case "ObjectPattern":
return this.visitObjectPattern(n);
case "AssignmentPattern":
return this.visitAssignmentPattern(n);
case "RestElement":
return this.visitRestElement(n);
default:
return this.visitExpression(n);
}
}
visitRestElement(n) {
n.argument = this.visitPattern(n.argument);
n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
return n;
}
visitAssignmentPattern(n) {
n.left = this.visitPattern(n.left);
n.right = this.visitExpression(n.right);
n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
return n;
}
visitObjectPattern(n) {
n.properties = this.visitObjectPatternProperties(n.properties || []);
n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
return n;
}
visitObjectPatternProperties(nodes) {
return nodes.map(this.visitObjectPatternProperty.bind(this));
}
visitObjectPatternProperty(n) {
switch (n.type) {
case "AssignmentPatternProperty":
return this.visitAssignmentPatternProperty(n);
case "KeyValuePatternProperty":
return this.visitKeyValuePatternProperty(n);
case "RestElement":
return this.visitRestElement(n);
}
}
visitKeyValuePatternProperty(n) {
n.key = this.visitPropertyName(n.key);
n.value = this.visitPattern(n.value);
return n;
}
visitAssignmentPatternProperty(n) {
n.key = this.visitBindingIdentifier(n.key);
n.value = this.visitOptionalExpression(n.value);
return n;
}
visitArrayPattern(n) {
n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
n.elements = this.visitArrayPatternElements(n.elements);
return n;
}
visitArrayPatternElements(nodes) {
return nodes.map(this.visitArrayPatternElement.bind(this));
}
visitArrayPatternElement(n) {
if (n) {
n = this.visitPattern(n);
}
return n;
}
}
exports.Visitor = Visitor;
exports.default = Visitor;