@graphcommerce/next-config 8.1.0-canary.2 → 8.1.0-canary.5

package/src/interceptors/Visitor.ts

@@ -0,0 +1,1847 @@
+/**
+ * This is an implementation of
+ * https://github.com/swc-project/swc/blob/main/node-swc/src/Visitor.ts
+ *
+ * The JS API is deprecated, but there doesn't seem to be a valid alternative at this point.
+ */
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable no-param-reassign */
+/* eslint-disable class-methods-use-this */
+/* eslint-disable consistent-return */
+// eslint-disable-next-line import/no-extraneous-dependencies
+import {
+  Accessibility,
+  Argument,
+  ArrayExpression,
+  ArrayPattern,
+  ArrowFunctionExpression,
+  AssignmentExpression,
+  AssignmentPattern,
+  AssignmentPatternProperty,
+  AssignmentProperty,
+  AwaitExpression,
+  BigIntLiteral,
+  BinaryExpression,
+  BindingIdentifier,
+  BlockStatement,
+  BooleanLiteral,
+  BreakStatement,
+  CallExpression,
+  CatchClause,
+  Class,
+  ClassDeclaration,
+  ClassExpression,
+  ClassMember,
+  ClassMethod,
+  ClassProperty,
+  ComputedPropName,
+  ConditionalExpression,
+  Constructor,
+  ContinueStatement,
+  DebuggerStatement,
+  Declaration,
+  Decorator,
+  DefaultDecl,
+  DoWhileStatement,
+  EmptyStatement,
+  ExportAllDeclaration,
+  ExportDeclaration,
+  ExportDefaultDeclaration,
+  ExportDefaultExpression,
+  ExportDefaultSpecifier,
+  ExportNamedDeclaration,
+  ExportNamespaceSpecifier,
+  ExportSpecifier,
+  ExprOrSpread,
+  Expression,
+  ExpressionStatement,
+  Fn,
+  ForInStatement,
+  ForOfStatement,
+  ForStatement,
+  FunctionDeclaration,
+  FunctionExpression,
+  GetterProperty,
+  Identifier,
+  IfStatement,
+  Import,
+  ImportDeclaration,
+  ImportDefaultSpecifier,
+  ImportNamespaceSpecifier,
+  ImportSpecifier,
+  JSXAttrValue,
+  JSXAttribute,
+  JSXAttributeName,
+  JSXAttributeOrSpread,
+  JSXClosingElement,
+  JSXClosingFragment,
+  JSXElement,
+  JSXElementChild,
+  JSXElementName,
+  JSXEmptyExpression,
+  JSXExpressionContainer,
+  JSXFragment,
+  JSXMemberExpression,
+  JSXNamespacedName,
+  JSXObject,
+  JSXOpeningElement,
+  JSXOpeningFragment,
+  JSXSpreadChild,
+  JSXText,
+  KeyValuePatternProperty,
+  KeyValueProperty,
+  LabeledStatement,
+  MemberExpression,
+  MetaProperty,
+  MethodProperty,
+  Module,
+  ModuleDeclaration,
+  ModuleExportName,
+  ModuleItem,
+  NamedExportSpecifier,
+  NamedImportSpecifier,
+  NewExpression,
+  NullLiteral,
+  NumericLiteral,
+  ObjectExpression,
+  ObjectPattern,
+  ObjectPatternProperty,
+  OptionalChainingCall,
+  OptionalChainingExpression,
+  Param,
+  ParenthesisExpression,
+  Pattern,
+  PrivateMethod,
+  PrivateName,
+  PrivateProperty,
+  Program,
+  Property,
+  PropertyName,
+  RegExpLiteral,
+  RestElement,
+  ReturnStatement,
+  Script,
+  SequenceExpression,
+  SetterProperty,
+  SpreadElement,
+  Statement,
+  StaticBlock,
+  StringLiteral,
+  Super,
+  SuperPropExpression,
+  SwitchCase,
+  SwitchStatement,
+  TaggedTemplateExpression,
+  TemplateLiteral,
+  ThisExpression,
+  ThrowStatement,
+  TryStatement,
+  TsAsExpression,
+  TsCallSignatureDeclaration,
+  TsConstAssertion,
+  TsConstructSignatureDeclaration,
+  TsEntityName,
+  TsEnumDeclaration,
+  TsEnumMember,
+  TsEnumMemberId,
+  TsExportAssignment,
+  TsExpressionWithTypeArguments,
+  TsExternalModuleReference,
+  TsFnParameter,
+  TsGetterSignature,
+  TsImportEqualsDeclaration,
+  TsIndexSignature,
+  TsInstantiation,
+  TsInterfaceBody,
+  TsInterfaceDeclaration,
+  TsMethodSignature,
+  TsModuleBlock,
+  TsModuleDeclaration,
+  TsModuleName,
+  TsModuleReference,
+  TsNamespaceBody,
+  TsNamespaceDeclaration,
+  TsNamespaceExportDeclaration,
+  TsNonNullExpression,
+  TsParameterProperty,
+  TsParameterPropertyParameter,
+  TsPropertySignature,
+  TsQualifiedName,
+  TsSatisfiesExpression,
+  TsSetterSignature,
+  TsType,
+  TsTypeAliasDeclaration,
+  TsTypeAnnotation,
+  TsTypeAssertion,
+  TsTypeElement,
+  TsTypeParameter,
+  TsTypeParameterDeclaration,
+  TsTypeParameterInstantiation,
+  UnaryExpression,
+  UpdateExpression,
+  VariableDeclaration,
+  VariableDeclarator,
+  WhileStatement,
+  WithStatement,
+  YieldExpression,
+} from '@swc/types'
+
+/**
+ * @deprecated JavaScript API is deprecated. Please use Wasm plugin instead.
+ */
+export class Visitor {
+  visitProgram(n: Program): Program {
+    switch (n.type) {
+      case 'Module':
+        return this.visitModule(n)
+      case 'Script':
+        return this.visitScript(n)
+    }
+  }
+
+  visitModule(m: Module): Module {
+    m.body = this.visitModuleItems(m.body)
+    return m
+  }
+
+  visitScript(m: Script): Script {
+    m.body = this.visitStatements(m.body)
+    return m
+  }
+
+  visitModuleItems(items: ModuleItem[]): ModuleItem[] {
+    return items.map(this.visitModuleItem.bind(this))
+  }
+
+  visitModuleItem(n: ModuleItem): ModuleItem {
+    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: ModuleDeclaration): ModuleDeclaration {
+    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: TsNamespaceExportDeclaration): ModuleDeclaration {
+    n.id = this.visitBindingIdentifier(n.id)
+    return n
+  }
+
+  visitTsExportAssignment(n: TsExportAssignment): TsExportAssignment {
+    n.expression = this.visitExpression(n.expression)
+
+    return n
+  }
+
+  visitTsImportEqualsDeclaration(n: TsImportEqualsDeclaration): ModuleDeclaration {
+    n.id = this.visitBindingIdentifier(n.id)
+    n.moduleRef = this.visitTsModuleReference(n.moduleRef)
+    return n
+  }
+
+  visitTsModuleReference(n: TsModuleReference): TsModuleReference {
+    switch (n.type) {
+      case 'Identifier':
+        return this.visitIdentifierReference(n)
+      case 'TsExternalModuleReference':
+        return this.visitTsExternalModuleReference(n)
+      case 'TsQualifiedName':
+        return this.visitTsQualifiedName(n)
+    }
+  }
+
+  visitTsExternalModuleReference(n: TsExternalModuleReference): TsExternalModuleReference {
+    n.expression = this.visitStringLiteral(n.expression)
+    return n
+  }
+
+  visitExportAllDeclaration(n: ExportAllDeclaration): ModuleDeclaration {
+    n.source = this.visitStringLiteral(n.source)
+    return n
+  }
+
+  visitExportDefaultExpression(n: ExportDefaultExpression): ModuleDeclaration {
+    n.expression = this.visitExpression(n.expression)
+    return n
+  }
+
+  visitExportNamedDeclaration(n: ExportNamedDeclaration): ModuleDeclaration {
+    n.specifiers = this.visitExportSpecifiers(n.specifiers)
+    n.source = this.visitOptionalStringLiteral(n.source)
+    return n
+  }
+
+  visitExportSpecifiers(nodes: ExportSpecifier[]): ExportSpecifier[] {
+    return nodes.map(this.visitExportSpecifier.bind(this))
+  }
+
+  visitExportSpecifier(n: ExportSpecifier): ExportSpecifier {
+    switch (n.type) {
+      case 'ExportDefaultSpecifier':
+        return this.visitExportDefaultSpecifier(n)
+      case 'ExportNamespaceSpecifier':
+        return this.visitExportNamespaceSpecifier(n)
+      case 'ExportSpecifier':
+        return this.visitNamedExportSpecifier(n)
+    }
+  }
+
+  visitNamedExportSpecifier(n: NamedExportSpecifier): ExportSpecifier {
+    if (n.exported) {
+      n.exported = this.visitModuleExportName(n.exported)
+    }
+    n.orig = this.visitModuleExportName(n.orig)
+    return n
+  }
+
+  visitModuleExportName(n: ModuleExportName): ModuleExportName {
+    switch (n.type) {
+      case 'Identifier':
+        return this.visitIdentifier(n)
+      case 'StringLiteral':
+        return this.visitStringLiteral(n)
+    }
+  }
+
+  visitExportNamespaceSpecifier(n: ExportNamespaceSpecifier): ExportSpecifier {
+    n.name = this.visitModuleExportName(n.name)
+    return n
+  }
+
+  visitExportDefaultSpecifier(n: ExportDefaultSpecifier): ExportSpecifier {
+    n.exported = this.visitBindingIdentifier(n.exported)
+    return n
+  }
+
+  visitOptionalStringLiteral(n: StringLiteral | undefined): StringLiteral | undefined {
+    if (n) {
+      return this.visitStringLiteral(n)
+    }
+  }
+
+  visitExportDefaultDeclaration(n: ExportDefaultDeclaration): ModuleDeclaration {
+    n.decl = this.visitDefaultDeclaration(n.decl)
+    return n
+  }
+
+  visitDefaultDeclaration(n: DefaultDecl): DefaultDecl {
+    switch (n.type) {
+      case 'ClassExpression':
+        return this.visitClassExpression(n)
+      case 'FunctionExpression':
+        return this.visitFunctionExpression(n)
+      case 'TsInterfaceDeclaration':
+        return this.visitTsInterfaceDeclaration(n)
+    }
+  }
+
+  visitFunctionExpression(n: FunctionExpression): FunctionExpression {
+    n = this.visitFunction(n)
+    if (n.identifier) {
+      n.identifier = this.visitBindingIdentifier(n.identifier)
+    }
+    return n
+  }
+
+  visitClassExpression(n: ClassExpression): ClassExpression {
+    n = this.visitClass(n)
+    if (n.identifier) {
+      n.identifier = this.visitBindingIdentifier(n.identifier)
+    }
+    return n
+  }
+
+  visitExportDeclaration(n: ExportDeclaration): ModuleDeclaration {
+    n.declaration = this.visitDeclaration(n.declaration)
+    return n
+  }
+
+  visitArrayExpression(e: ArrayExpression): Expression {
+    if (e.elements) {
+      e.elements = e.elements.map(this.visitArrayElement.bind(this))
+    }
+    return e
+  }
+
+  visitArrayElement(e: ExprOrSpread | undefined): ExprOrSpread | undefined {
+    if (e) {
+      return this.visitExprOrSpread(e)
+    }
+  }
+
+  visitExprOrSpread(e: ExprOrSpread): ExprOrSpread {
+    return {
+      ...e,
+      expression: this.visitExpression(e.expression),
+    }
+  }
+
+  visitExprOrSpreads(nodes: ExprOrSpread[]): ExprOrSpread[] {
+    return nodes.map(this.visitExprOrSpread.bind(this))
+  }
+
+  visitSpreadElement(e: SpreadElement): SpreadElement {
+    e.arguments = this.visitExpression(e.arguments)
+    return e
+  }
+
+  visitOptionalExpression(e: Expression | undefined): Expression | undefined {
+    if (e) {
+      return this.visitExpression(e)
+    }
+  }
+
+  visitArrowFunctionExpression(e: ArrowFunctionExpression): Expression {
+    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: BlockStatement | Expression): BlockStatement | Expression {
+    switch (body.type) {
+      case 'BlockStatement':
+        return this.visitBlockStatement(body)
+      default:
+        return this.visitExpression(body)
+    }
+  }
+
+  visitBlockStatement(block: BlockStatement): BlockStatement {
+    block.stmts = this.visitStatements(block.stmts)
+
+    return block
+  }
+
+  visitStatements(stmts: Statement[]): Statement[] {
+    return stmts.map(this.visitStatement.bind(this))
+  }
+
+  visitStatement(stmt: Statement): Statement {
+    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 as any).type}`)
+    }
+  }
+
+  visitSwitchStatement(stmt: SwitchStatement): Statement {
+    stmt.discriminant = this.visitExpression(stmt.discriminant)
+    stmt.cases = this.visitSwitchCases(stmt.cases)
+    return stmt
+  }
+
+  visitSwitchCases(cases: SwitchCase[]): SwitchCase[] {
+    return cases.map(this.visitSwitchCase.bind(this))
+  }
+
+  visitSwitchCase(c: SwitchCase): SwitchCase {
+    c.test = this.visitOptionalExpression(c.test)
+    c.consequent = this.visitStatements(c.consequent)
+
+    return c
+  }
+
+  visitIfStatement(stmt: IfStatement): Statement {
+    stmt.test = this.visitExpression(stmt.test)
+    stmt.consequent = this.visitStatement(stmt.consequent)
+    stmt.alternate = this.visitOptionalStatement(stmt.alternate)
+
+    return stmt
+  }
+
+  visitOptionalStatement(stmt: Statement | undefined): Statement | undefined {
+    if (stmt) {
+      return this.visitStatement(stmt)
+    }
+  }
+
+  visitBreakStatement(stmt: BreakStatement): Statement {
+    if (stmt.label) {
+      stmt.label = this.visitLabelIdentifier(stmt.label)
+    }
+
+    return stmt
+  }
+
+  visitWhileStatement(stmt: WhileStatement): Statement {
+    stmt.test = this.visitExpression(stmt.test)
+    stmt.body = this.visitStatement(stmt.body)
+    return stmt
+  }
+
+  visitTryStatement(stmt: TryStatement): Statement {
+    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: CatchClause | undefined): CatchClause | undefined {
+    if (handler) {
+      if (handler.param) {
+        handler.param = this.visitPattern(handler.param)
+      }
+
+      handler.body = this.visitBlockStatement(handler.body)
+    }
+
+    return handler
+  }
+
+  visitThrowStatement(stmt: ThrowStatement): Statement {
+    stmt.argument = this.visitExpression(stmt.argument)
+    return stmt
+  }
+
+  visitReturnStatement(stmt: ReturnStatement): Statement {
+    if (stmt.argument) {
+      stmt.argument = this.visitExpression(stmt.argument)
+    }
+    return stmt
+  }
+
+  visitLabeledStatement(stmt: LabeledStatement): Statement {
+    stmt.label = this.visitLabelIdentifier(stmt.label)
+    stmt.body = this.visitStatement(stmt.body)
+
+    return stmt
+  }
+
+  visitForStatement(stmt: ForStatement): Statement {
+    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: ForOfStatement): Statement {
+    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: ForInStatement): Statement {
+    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: EmptyStatement): EmptyStatement {
+    return stmt
+  }
+
+  visitDoWhileStatement(stmt: DoWhileStatement): Statement {
+    stmt.body = this.visitStatement(stmt.body)
+    stmt.test = this.visitExpression(stmt.test)
+    return stmt
+  }
+
+  visitDebuggerStatement(stmt: DebuggerStatement): Statement {
+    return stmt
+  }
+
+  visitWithStatement(stmt: WithStatement): Statement {
+    stmt.object = this.visitExpression(stmt.object)
+    stmt.body = this.visitStatement(stmt.body)
+    return stmt
+  }
+
+  visitDeclaration(decl: Declaration): Declaration {
+    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: VariableDeclaration): VariableDeclaration {
+    n.declarations = this.visitVariableDeclarators(n.declarations)
+    return n
+  }
+
+  visitVariableDeclarators(nodes: VariableDeclarator[]): VariableDeclarator[] {
+    return nodes.map(this.visitVariableDeclarator.bind(this))
+  }
+
+  visitVariableDeclarator(n: VariableDeclarator): VariableDeclarator {
+    n.id = this.visitPattern(n.id)
+    n.init = this.visitOptionalExpression(n.init)
+    return n
+  }
+
+  visitTsTypeAliasDeclaration(n: TsTypeAliasDeclaration): Declaration {
+    n.id = this.visitBindingIdentifier(n.id)
+    n.typeAnnotation = this.visitTsType(n.typeAnnotation)
+    n.typeParams = this.visitTsTypeParameterDeclaration(n.typeParams)
+    return n
+  }
+
+  visitTsModuleDeclaration(n: TsModuleDeclaration): Declaration {
+    n.id = this.visitTsModuleName(n.id)
+    if (n.body) {
+      n.body = this.visitTsNamespaceBody(n.body)
+    }
+    return n
+  }
+
+  visitTsModuleName(n: TsModuleName): TsModuleName {
+    switch (n.type) {
+      case 'Identifier':
+        return this.visitBindingIdentifier(n)
+      case 'StringLiteral':
+        return this.visitStringLiteral(n)
+    }
+  }
+
+  visitTsNamespaceBody(n: TsNamespaceBody): TsNamespaceBody | undefined {
+    if (n) {
+      switch (n.type) {
+        case 'TsModuleBlock':
+          return this.visitTsModuleBlock(n)
+        case 'TsNamespaceDeclaration':
+          return this.visitTsNamespaceDeclaration(n)
+      }
+    }
+  }
+
+  visitTsNamespaceDeclaration(n: TsNamespaceDeclaration): TsModuleBlock | TsNamespaceDeclaration {
+    const body = this.visitTsNamespaceBody(n.body)
+    if (body) {
+      n.body = body
+    }
+    n.id = this.visitBindingIdentifier(n.id)
+    return n
+  }
+
+  visitTsModuleBlock(n: TsModuleBlock): TsModuleBlock | TsNamespaceDeclaration {
+    n.body = this.visitModuleItems(n.body)
+    return n
+  }
+
+  visitTsInterfaceDeclaration(n: TsInterfaceDeclaration): TsInterfaceDeclaration {
+    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: TsInterfaceBody): TsInterfaceBody {
+    n.body = this.visitTsTypeElements(n.body)
+    return n
+  }
+
+  visitTsTypeElements(nodes: TsTypeElement[]): TsTypeElement[] {
+    return nodes.map(this.visitTsTypeElement.bind(this))
+  }
+
+  visitTsTypeElement(n: TsTypeElement): TsTypeElement {
+    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: TsCallSignatureDeclaration): TsCallSignatureDeclaration {
+    n.params = this.visitTsFnParameters(n.params)
+    n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation)
+    return n
+  }
+
+  visitTsConstructSignatureDeclaration(
+    n: TsConstructSignatureDeclaration,
+  ): TsConstructSignatureDeclaration {
+    n.params = this.visitTsFnParameters(n.params)
+    n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation)
+    return n
+  }
+
+  visitTsPropertySignature(n: TsPropertySignature): TsPropertySignature {
+    n.params = this.visitTsFnParameters(n.params)
+    n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation)
+    return n
+  }
+
+  visitTsGetterSignature(n: TsGetterSignature): TsGetterSignature {
+    n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation)
+    return n
+  }
+
+  visitTsSetterSignature(n: TsSetterSignature): TsSetterSignature {
+    n.param = this.visitTsFnParameter(n.param)
+    return n
+  }
+
+  visitTsMethodSignature(n: TsMethodSignature): TsMethodSignature {
+    n.params = this.visitTsFnParameters(n.params)
+    n.typeAnn = this.visitTsTypeAnnotation(n.typeAnn)
+    return n
+  }
+
+  visitTsEnumDeclaration(n: TsEnumDeclaration): Declaration {
+    n.id = this.visitIdentifier(n.id)
+    n.members = this.visitTsEnumMembers(n.members)
+    return n
+  }
+
+  visitTsEnumMembers(nodes: TsEnumMember[]): TsEnumMember[] {
+    return nodes.map(this.visitTsEnumMember.bind(this))
+  }
+
+  visitTsEnumMember(n: TsEnumMember): TsEnumMember {
+    n.id = this.visitTsEnumMemberId(n.id)
+    n.init = this.visitOptionalExpression(n.init)
+    return n
+  }
+
+  visitTsEnumMemberId(n: TsEnumMemberId): TsEnumMemberId {
+    switch (n.type) {
+      case 'Identifier':
+        return this.visitBindingIdentifier(n)
+      case 'StringLiteral':
+        return this.visitStringLiteral(n)
+    }
+  }
+
+  visitFunctionDeclaration(decl: FunctionDeclaration): Declaration {
+    decl.identifier = this.visitIdentifier(decl.identifier)
+    decl = this.visitFunction(decl)
+
+    return decl
+  }
+
+  visitClassDeclaration(decl: ClassDeclaration): Declaration {
+    decl = this.visitClass(decl)
+    decl.identifier = this.visitIdentifier(decl.identifier)
+    return decl
+  }
+
+  visitClassBody(members: ClassMember[]): ClassMember[] {
+    return members.map(this.visitClassMember.bind(this))
+  }
+
+  visitClassMember(member: ClassMember): ClassMember {
+    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: TsIndexSignature): TsIndexSignature {
+    n.params = this.visitTsFnParameters(n.params)
+    if (n.typeAnnotation) n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation)
+    return n
+  }
+
+  visitTsFnParameters(params: TsFnParameter[]): TsFnParameter[] {
+    return params.map(this.visitTsFnParameter.bind(this))
+  }
+
+  visitTsFnParameter(n: TsFnParameter): TsFnParameter {
+    n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation)
+    return n
+  }
+
+  visitPrivateProperty(n: PrivateProperty): ClassMember {
+    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: PrivateMethod): ClassMember {
+    n.accessibility = this.visitAccessibility(n.accessibility)
+    n.function = this.visitFunction(n.function)
+    n.key = this.visitPrivateName(n.key)
+    return n
+  }
+
+  visitPrivateName(n: PrivateName): PrivateName {
+    return n
+  }
+
+  visitConstructor(n: Constructor): ClassMember {
+    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: (Param | TsParameterProperty)[],
+  ): (Param | TsParameterProperty)[] {
+    return nodes.map(this.visitConstructorParameter.bind(this))
+  }
+
+  visitConstructorParameter(n: Param | TsParameterProperty): Param | TsParameterProperty {
+    switch (n.type) {
+      case 'TsParameterProperty':
+        return this.visitTsParameterProperty(n)
+      default:
+        return this.visitParameter(n)
+    }
+  }
+
+  visitStaticBlock(n: StaticBlock): StaticBlock {
+    n.body = this.visitBlockStatement(n.body)
+    return n
+  }
+
+  visitTsParameterProperty(n: TsParameterProperty): TsParameterProperty | Param {
+    n.accessibility = this.visitAccessibility(n.accessibility)
+    n.decorators = this.visitDecorators(n.decorators)
+    n.param = this.visitTsParameterPropertyParameter(n.param)
+    return n
+  }
+
+  visitTsParameterPropertyParameter(n: TsParameterPropertyParameter): TsParameterPropertyParameter {
+    n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation)
+    return n
+  }
+
+  visitPropertyName(key: PropertyName): PropertyName {
+    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: Accessibility | undefined): Accessibility | undefined {
+    return n
+  }
+
+  visitClassProperty(n: ClassProperty): ClassMember {
+    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: ClassMethod): ClassMember {
+    n.accessibility = this.visitAccessibility(n.accessibility)
+    n.function = this.visitFunction(n.function)
+    n.key = this.visitPropertyName(n.key)
+    return n
+  }
+
+  visitComputedPropertyKey(n: ComputedPropName): ComputedPropName {
+    n.expression = this.visitExpression(n.expression)
+    return n
+  }
+
+  visitClass<T extends Class>(n: T): T {
+    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<T extends Fn>(n: T): T {
+    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: TsExpressionWithTypeArguments[],
+  ): TsExpressionWithTypeArguments[] {
+    return nodes.map(this.visitTsExpressionWithTypeArguments.bind(this))
+  }
+
+  visitTsExpressionWithTypeArguments(
+    n: TsExpressionWithTypeArguments,
+  ): TsExpressionWithTypeArguments {
+    n.expression = this.visitExpression(n.expression)
+    n.typeArguments = this.visitTsTypeParameterInstantiation(n.typeArguments)
+    return n
+  }
+
+  visitTsTypeParameterInstantiation(
+    n: TsTypeParameterInstantiation | undefined,
+  ): TsTypeParameterInstantiation | undefined {
+    if (n) {
+      n.params = this.visitTsTypes(n.params)
+    }
+    return n
+  }
+
+  visitTsTypes(nodes: TsType[]): TsType[] {
+    return nodes.map(this.visitTsType.bind(this))
+  }
+
+  visitTsEntityName(n: TsEntityName): TsEntityName {
+    switch (n.type) {
+      case 'Identifier':
+        return this.visitBindingIdentifier(n)
+      case 'TsQualifiedName':
+        return this.visitTsQualifiedName(n)
+    }
+  }
+
+  visitTsQualifiedName(n: TsQualifiedName): TsQualifiedName {
+    n.left = this.visitTsEntityName(n.left)
+    n.right = this.visitIdentifier(n.right)
+    return n
+  }
+
+  visitDecorators(nodes: Decorator[] | undefined): Decorator[] | undefined {
+    if (nodes) {
+      return nodes.map(this.visitDecorator.bind(this))
+    }
+  }
+
+  visitDecorator(n: Decorator): Decorator {
+    n.expression = this.visitExpression(n.expression)
+
+    return n
+  }
+
+  visitExpressionStatement(stmt: ExpressionStatement): Statement {
+    stmt.expression = this.visitExpression(stmt.expression)
+    return stmt
+  }
+
+  visitContinueStatement(stmt: ContinueStatement): Statement {
+    if (stmt.label) {
+      stmt.label = this.visitLabelIdentifier(stmt.label)
+    }
+    return stmt
+  }
+
+  visitExpression(n: Expression): Expression {
+    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: OptionalChainingExpression): Expression {
+    n.base = this.visitMemberExpressionOrOptionalChainingCall(n.base)
+    return n
+  }
+
+  visitMemberExpressionOrOptionalChainingCall(
+    n: MemberExpression | OptionalChainingCall,
+  ): MemberExpression | OptionalChainingCall {
+    switch (n.type) {
+      case 'MemberExpression':
+        return this.visitMemberExpression(n)
+      case 'CallExpression':
+        return this.visitOptionalChainingCall(n)
+    }
+  }
+
+  visitOptionalChainingCall(n: OptionalChainingCall): OptionalChainingCall {
+    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: AssignmentExpression): Expression {
+    n.left = this.visitPatternOrExpression(n.left)
+    n.right = this.visitExpression(n.right)
+    return n
+  }
+
+  visitPatternOrExpression(n: Pattern | Expression): Pattern | Expression {
+    switch (n.type) {
+      case 'ObjectPattern':
+      case 'ArrayPattern':
+      case 'Identifier':
+      case 'AssignmentPattern':
+      case 'RestElement':
+        return this.visitPattern(n)
+      default:
+        return this.visitExpression(n)
+    }
+  }
+
+  visitYieldExpression(n: YieldExpression): Expression {
+    n.argument = this.visitOptionalExpression(n.argument)
+    return n
+  }
+
+  visitUpdateExpression(n: UpdateExpression): Expression {
+    n.argument = this.visitExpression(n.argument)
+    return n
+  }
+
+  visitUnaryExpression(n: UnaryExpression): Expression {
+    n.argument = this.visitExpression(n.argument)
+    return n
+  }
+
+  visitTsTypeAssertion(n: TsTypeAssertion): Expression {
+    n.expression = this.visitExpression(n.expression)
+    n.typeAnnotation = this.visitTsType(n.typeAnnotation)
+    return n
+  }
+
+  visitTsConstAssertion(n: TsConstAssertion): Expression {
+    n.expression = this.visitExpression(n.expression)
+    return n
+  }
+
+  visitTsInstantiation(n: TsInstantiation): TsInstantiation {
+    n.expression = this.visitExpression(n.expression)
+    return n
+  }
+
+  visitTsNonNullExpression(n: TsNonNullExpression): Expression {
+    n.expression = this.visitExpression(n.expression)
+    return n
+  }
+
+  visitTsAsExpression(n: TsAsExpression): Expression {
+    n.expression = this.visitExpression(n.expression)
+    n.typeAnnotation = this.visitTsType(n.typeAnnotation)
+    return n
+  }
+
+  visitTsSatisfiesExpression(n: TsSatisfiesExpression): Expression {
+    n.expression = this.visitExpression(n.expression)
+    n.typeAnnotation = this.visitTsType(n.typeAnnotation)
+    return n
+  }
+
+  visitThisExpression(n: ThisExpression): Expression {
+    return n
+  }
+
+  visitTemplateLiteral(n: TemplateLiteral): Expression {
+    n.expressions = n.expressions.map(this.visitExpression.bind(this))
+    return n
+  }
+
+  visitParameters(n: Param[]): Param[] {
+    return n.map(this.visitParameter.bind(this))
+  }
+
+  visitParameter(n: Param): Param {
+    n.pat = this.visitPattern(n.pat)
+    return n
+  }
+
+  visitTaggedTemplateExpression(n: TaggedTemplateExpression): Expression {
+    n.tag = this.visitExpression(n.tag)
+    const template = this.visitTemplateLiteral(n.template)
+    if (template.type === 'TemplateLiteral') {
+      n.template = template
+    }
+    return n
+  }
+
+  visitSequenceExpression(n: SequenceExpression): Expression {
+    n.expressions = n.expressions.map(this.visitExpression.bind(this))
+    return n
+  }
+
+  visitRegExpLiteral(n: RegExpLiteral): Expression {
+    return n
+  }
+
+  visitParenthesisExpression(n: ParenthesisExpression): Expression {
+    n.expression = this.visitExpression(n.expression)
+    return n
+  }
+
+  visitObjectExpression(n: ObjectExpression): Expression {
+    if (n.properties) {
+      n.properties = this.visitObjectProperties(n.properties)
+    }
+    return n
+  }
+
+  visitObjectProperties(nodes: (Property | SpreadElement)[]): (Property | SpreadElement)[] {
+    return nodes.map(this.visitObjectProperty.bind(this))
+  }
+
+  visitObjectProperty(n: Property | SpreadElement): Property | SpreadElement {
+    switch (n.type) {
+      case 'SpreadElement':
+        return this.visitSpreadElement(n)
+      default:
+        return this.visitProperty(n)
+    }
+  }
+
+  visitProperty(n: Property): Property | SpreadElement {
+    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: SetterProperty): Property | SpreadElement {
+    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: MethodProperty): Property | SpreadElement {
+    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: KeyValueProperty): Property | SpreadElement {
+    n.key = this.visitPropertyName(n.key)
+    n.value = this.visitExpression(n.value)
+    return n
+  }
+
+  visitGetterProperty(n: GetterProperty): Property | SpreadElement {
+    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: AssignmentProperty): Property | SpreadElement {
+    n.key = this.visitIdentifier(n.key)
+    n.value = this.visitExpression(n.value)
+    return n
+  }
+
+  visitNullLiteral(n: NullLiteral): NullLiteral {
+    return n
+  }
+
+  visitNewExpression(n: NewExpression): Expression {
+    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: TsTypeParameterInstantiation | undefined,
+  ): TsTypeParameterInstantiation | undefined {
+    if (n) {
+      n.params = this.visitTsTypes(n.params)
+    }
+    return n
+  }
+
+  visitArguments(nodes: Argument[]): Argument[] {
+    return nodes.map(this.visitArgument.bind(this))
+  }
+
+  visitArgument(n: Argument): Argument {
+    n.expression = this.visitExpression(n.expression)
+    return n
+  }
+
+  visitMetaProperty(n: MetaProperty): Expression {
+    return n
+  }
+
+  visitMemberExpression(n: MemberExpression): MemberExpression {
+    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: SuperPropExpression): Expression {
+    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: Expression | Super | Import): Expression | Super | Import {
+    if (n.type === 'Super' || n.type === 'Import') {
+      return n
+    }
+    return this.visitExpression(n)
+  }
+
+  visitJSXText(n: JSXText): JSXText {
+    return n
+  }
+
+  visitJSXNamespacedName(n: JSXNamespacedName): JSXNamespacedName {
+    n.namespace = this.visitIdentifierReference(n.namespace)
+    n.name = this.visitIdentifierReference(n.name)
+    return n
+  }
+
+  visitJSXMemberExpression(n: JSXMemberExpression): JSXMemberExpression {
+    n.object = this.visitJSXObject(n.object)
+    n.property = this.visitIdentifierReference(n.property)
+    return n
+  }
+
+  visitJSXObject(n: JSXObject): JSXObject {
+    switch (n.type) {
+      case 'Identifier':
+        return this.visitIdentifierReference(n)
+      case 'JSXMemberExpression':
+        return this.visitJSXMemberExpression(n)
+    }
+  }
+
+  visitJSXFragment(n: JSXFragment): JSXFragment {
+    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: JSXClosingFragment): JSXClosingFragment {
+    return n
+  }
+
+  visitJSXElementChildren(nodes: JSXElementChild[]): JSXElementChild[] {
+    return nodes.map(this.visitJSXElementChild.bind(this))
+  }
+
+  visitJSXElementChild(n: JSXElementChild): JSXElementChild {
+    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: JSXExpressionContainer): JSXExpressionContainer {
+    n.expression = this.visitExpression(n.expression)
+    return n
+  }
+
+  visitJSXSpreadChild(n: JSXSpreadChild): JSXElementChild {
+    n.expression = this.visitExpression(n.expression)
+    return n
+  }
+
+  visitJSXOpeningFragment(n: JSXOpeningFragment): JSXOpeningFragment {
+    return n
+  }
+
+  visitJSXEmptyExpression(n: JSXEmptyExpression): Expression {
+    return n
+  }
+
+  visitJSXElement(n: JSXElement): JSXElement {
+    n.opening = this.visitJSXOpeningElement(n.opening)
+    n.children = this.visitJSXElementChildren(n.children)
+    n.closing = this.visitJSXClosingElement(n.closing)
+    return n
+  }
+
+  visitJSXClosingElement(n: JSXClosingElement | undefined): JSXClosingElement | undefined {
+    if (n) {
+      n.name = this.visitJSXElementName(n.name)
+    }
+    return n
+  }
+
+  visitJSXElementName(n: JSXElementName): JSXElementName {
+    switch (n.type) {
+      case 'Identifier':
+        return this.visitIdentifierReference(n)
+      case 'JSXMemberExpression':
+        return this.visitJSXMemberExpression(n)
+      case 'JSXNamespacedName':
+        return this.visitJSXNamespacedName(n)
+    }
+  }
+
+  visitJSXOpeningElement(n: JSXOpeningElement): JSXOpeningElement {
+    n.name = this.visitJSXElementName(n.name)
+    n.typeArguments = this.visitTsTypeParameterInstantiation(n.typeArguments)
+    n.attributes = this.visitJSXAttributeOrSpreads(n.attributes)
+    return n
+  }
+
+  visitJSXAttributes(
+    attrs: JSXAttributeOrSpread[] | undefined,
+  ): JSXAttributeOrSpread[] | undefined {
+    if (attrs) return attrs.map(this.visitJSXAttributeOrSpread.bind(this))
+  }
+
+  visitJSXAttributeOrSpread(n: JSXAttributeOrSpread): JSXAttributeOrSpread {
+    switch (n.type) {
+      case 'JSXAttribute':
+        return this.visitJSXAttribute(n)
+      case 'SpreadElement':
+        return this.visitSpreadElement(n)
+    }
+  }
+
+  visitJSXAttributeOrSpreads(nodes: JSXAttributeOrSpread[]): JSXAttributeOrSpread[] {
+    return nodes.map(this.visitJSXAttributeOrSpread.bind(this))
+  }
+
+  visitJSXAttribute(n: JSXAttribute): JSXAttributeOrSpread {
+    n.name = this.visitJSXAttributeName(n.name)
+    n.value = this.visitJSXAttributeValue(n.value)
+    return n
+  }
+
+  visitJSXAttributeValue(n: JSXAttrValue | undefined): JSXAttrValue | undefined {
+    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: JSXAttributeName): JSXAttributeName {
+    switch (n.type) {
+      case 'Identifier':
+        return this.visitIdentifierReference(n)
+      case 'JSXNamespacedName':
+        return this.visitJSXNamespacedName(n)
+    }
+  }
+
+  visitConditionalExpression(n: ConditionalExpression): Expression {
+    n.test = this.visitExpression(n.test)
+    n.consequent = this.visitExpression(n.consequent)
+    n.alternate = this.visitExpression(n.alternate)
+    return n
+  }
+
+  visitCallExpression(n: CallExpression): Expression {
+    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: BooleanLiteral): BooleanLiteral {
+    return n
+  }
+
+  visitBinaryExpression(n: BinaryExpression): Expression {
+    n.left = this.visitExpression(n.left)
+    n.right = this.visitExpression(n.right)
+    return n
+  }
+
+  visitAwaitExpression(n: AwaitExpression): Expression {
+    n.argument = this.visitExpression(n.argument)
+    return n
+  }
+
+  visitTsTypeParameterDeclaration(
+    n: TsTypeParameterDeclaration | undefined,
+  ): TsTypeParameterDeclaration | undefined {
+    if (n) {
+      n.parameters = this.visitTsTypeParameters(n.parameters)
+    }
+    return n
+  }
+
+  visitTsTypeParameters(nodes: TsTypeParameter[]): TsTypeParameter[] {
+    return nodes.map(this.visitTsTypeParameter.bind(this))
+  }
+
+  visitTsTypeParameter(n: TsTypeParameter): TsTypeParameter {
+    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: TsTypeAnnotation | undefined): TsTypeAnnotation | undefined {
+    if (a) {
+      a.typeAnnotation = this.visitTsType(a.typeAnnotation)
+    }
+    return a
+  }
+
+  visitTsType(n: TsType): TsType {
+    return n
+    throw new Error('Method visitTsType not implemented.')
+  }
+
+  visitPatterns(nodes: Pattern[]): Pattern[] {
+    return nodes.map(this.visitPattern.bind(this))
+  }
+
+  visitImportDeclaration(n: ImportDeclaration): ImportDeclaration {
+    n.source = this.visitStringLiteral(n.source)
+    n.specifiers = this.visitImportSpecifiers(n.specifiers || [])
+    return n
+  }
+
+  visitImportSpecifiers(nodes: ImportSpecifier[]): ImportSpecifier[] {
+    return nodes.map(this.visitImportSpecifier.bind(this))
+  }
+
+  visitImportSpecifier(node: ImportSpecifier): ImportSpecifier {
+    switch (node.type) {
+      case 'ImportDefaultSpecifier':
+        return this.visitImportDefaultSpecifier(node)
+
+      case 'ImportNamespaceSpecifier':
+        return this.visitImportNamespaceSpecifier(node)
+
+      case 'ImportSpecifier':
+        return this.visitNamedImportSpecifier(node)
+    }
+  }
+
+  visitNamedImportSpecifier(node: NamedImportSpecifier): NamedImportSpecifier {
+    node.local = this.visitBindingIdentifier(node.local)
+
+    if (node.imported) {
+      node.imported = this.visitModuleExportName(node.imported)
+    }
+
+    return node
+  }
+
+  visitImportNamespaceSpecifier(node: ImportNamespaceSpecifier): ImportNamespaceSpecifier {
+    node.local = this.visitBindingIdentifier(node.local)
+
+    return node
+  }
+
+  visitImportDefaultSpecifier(node: ImportDefaultSpecifier): ImportSpecifier {
+    node.local = this.visitBindingIdentifier(node.local)
+
+    return node
+  }
+
+  visitBindingIdentifier(i: BindingIdentifier): BindingIdentifier {
+    if (i.typeAnnotation) {
+      i.typeAnnotation = this.visitTsTypeAnnotation(i.typeAnnotation)
+    }
+    return this.visitIdentifier(i)
+  }
+
+  visitIdentifierReference(i: Identifier): Identifier {
+    return this.visitIdentifier(i)
+  }
+
+  visitLabelIdentifier(label: Identifier): Identifier {
+    return this.visitIdentifier(label)
+  }
+
+  visitIdentifier(n: Identifier): Identifier {
+    return n
+  }
+
+  visitStringLiteral(n: StringLiteral): StringLiteral {
+    return n
+  }
+
+  visitNumericLiteral(n: NumericLiteral): NumericLiteral {
+    return n
+  }
+
+  visitBigIntLiteral(n: BigIntLiteral): BigIntLiteral {
+    return n
+  }
+
+  visitPattern(n: Pattern): Pattern {
+    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: RestElement): RestElement {
+    n.argument = this.visitPattern(n.argument)
+    n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation)
+    return n
+  }
+
+  visitAssignmentPattern(n: AssignmentPattern): Pattern {
+    n.left = this.visitPattern(n.left)
+    n.right = this.visitExpression(n.right)
+    n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation)
+    return n
+  }
+
+  visitObjectPattern(n: ObjectPattern): Pattern {
+    n.properties = this.visitObjectPatternProperties(n.properties || [])
+    n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation)
+    return n
+  }
+
+  visitObjectPatternProperties(nodes: ObjectPatternProperty[]): ObjectPatternProperty[] {
+    return nodes.map(this.visitObjectPatternProperty.bind(this))
+  }
+
+  visitObjectPatternProperty(n: ObjectPatternProperty): ObjectPatternProperty {
+    switch (n.type) {
+      case 'AssignmentPatternProperty':
+        return this.visitAssignmentPatternProperty(n)
+      case 'KeyValuePatternProperty':
+        return this.visitKeyValuePatternProperty(n)
+      case 'RestElement':
+        return this.visitRestElement(n)
+    }
+  }
+
+  visitKeyValuePatternProperty(n: KeyValuePatternProperty): ObjectPatternProperty {
+    n.key = this.visitPropertyName(n.key)
+    n.value = this.visitPattern(n.value)
+    return n
+  }
+
+  visitAssignmentPatternProperty(n: AssignmentPatternProperty): ObjectPatternProperty {
+    n.key = this.visitBindingIdentifier(n.key)
+    n.value = this.visitOptionalExpression(n.value)
+    return n
+  }
+
+  visitArrayPattern(n: ArrayPattern): Pattern {
+    n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation)
+    n.elements = this.visitArrayPatternElements(n.elements)
+    return n
+  }
+
+  visitArrayPatternElements(nodes: (Pattern | undefined)[]): (Pattern | undefined)[] {
+    return nodes.map(this.visitArrayPatternElement.bind(this))
+  }
+
+  visitArrayPatternElement(n: Pattern | undefined): Pattern | undefined {
+    if (n) {
+      n = this.visitPattern(n)
+    }
+    return n
+  }
+}
+
+export default Visitor