bmdl-sdk 2.0.39 → 2.0.41

package/dist/standalone/node_modules/@swc/core/Visitor.js

@@ -1,1399 +0,0 @@
-"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 "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;