anchor.diff:      inherit Compiler
       //abstract GetAllImports: unit -> seq<Python.Import>
       //abstract GetImportExpr: Context * selector: string * path: string * SourceLocation option -> Expression
  -    abstract TransformAsExpr: Context * Babel.Expression -> Expression
  +    abstract TransformAsExpr: Context * Babel.Expression -> Expression * Statement list
       abstract TransformAsStatements: Context * ReturnStrategy option * Babel.Statement -> Statement list
       abstract TransformAsStatements: Context * ReturnStrategy option * Babel.Expression -> Statement list
       abstract TransformAsClassDef: Context * Babel.ClassDeclaration -> Statement
  
positive.code:                     match decl.Declaration with
                      | :? Babel.VariableDeclaration as decl ->
                          for decls in decl.Declarations do
                              let value = com.TransformAsExpr(ctx, decls.Init.Value)
                              let targets: Expression list =
                                  [ Name(id = Identifier(decls.Id.Name), ctx = Store()) ]
  
                              yield Assign(targets = targets, value = value)
                      | :? Babel.FunctionDeclaration as fd ->
                          let args =
  
negative.code: 
  
  module Helpers =
      let random = Random ()
  
      let getIdentifier(name: string) : Identifier =
          let rand = random.Next(9999).ToString()
          Identifier($"{name}_{rand}")
  
      /// Camel case to snake case converter.
      let camel2snake (name: string) =
          name
          |> Seq.mapi
              (fun i n ->
                  if i > 0 && Char.IsUpper n then
                      "_" + n.ToString().ToLower()
                  else
                      n.ToString())
          |> String.concat ""
  
      /// Replaces all '$' with '_'
      let cleanNameAsPythonIdentifier (name: string) = name.Replace('$', '_')
  
      let rewriteFableImport moduleName specifiers =
          let _reFableLib =
              Regex(".*\/fable-library[\.0-9]*\/(?<module>[^\/]*)\.js", RegexOptions.Compiled)
  
          let m = _reFableLib.Match(moduleName)
  
          if m.Groups.Count > 0 then
              let pymodule = m.Groups.["module"].Value.ToLower()
  
              let moduleName =
                  String.concat "." [ "expression"; "fable"; pymodule ]
  
              moduleName, specifiers
          else
              moduleName, specifiers
  
      let unzipArgs (args: (Expression * Statement list) list): Expression list * Statement list =
          let stmts = args |> List.map snd |> List.collect id
          let args = args |> List.map fst
          args, stmts
  
  module Util =
      let transformAsImport (com: IPythonCompiler) (ctx: Context) (imp: Babel.ImportDeclaration): Statement =
  
          let specifier2string (expr: Babel.ImportSpecifier) =
              match expr with
              | :? Babel.ImportMemberSpecifier as im -> im.Imported.Name
              | _ -> failwith $"Unhandled import: {expr}"
  
          let specifiers =
              imp.Specifiers
              |> List.ofArray
              |> List.map specifier2string
  
          let pymodule, names =
              Helpers.rewriteFableImport imp.Source.Value specifiers
  
  
          let aliases =
              names
              |> List.map (fun name -> Alias(Identifier name, None))
  
          ImportFrom(pymodule |> Identifier |> Some, aliases) :> _
  
      let transformAsClassDef (com: IPythonCompiler) ctx (cls: Babel.ClassDeclaration): Statement =
          printfn $"transformAsClassDef"
  
          let body: Statement list =
              [ for mber in cls.Body.Body do
                  match mber with
                  | :? Babel.ClassMethod as cm ->
                      match cm.Kind with
                      | "constructor" ->
                          let self = Arg(Identifier("self"))
  
                          let args =
                              cm.Params
                              |> List.ofArray
                              |> List.map (fun arg -> Arg(Identifier(arg.Name)))
  
                          let arguments = Arguments(args = self :: args)
  
                          let body =
                              com.TransformAsStatements(ctx, (Some ReturnStrategy.ReturnUnit), cm.Body)
  
                          FunctionDef(Identifier "__init__", arguments, body = body)
                      | _ -> failwith $"Unknown kind: {cm.Kind}"
                  | _ -> failwith $"Unhandled class member {mber}" ]
  
          ClassDef(Identifier(cls.Id.Value.Name), body = body) :> _
  
      /// Transform Babel expression as Python expression
      let rec transformAsExpr (com: IPythonCompiler) (ctx: Context) (expr: Babel.Expression): Expression * list<Statement> =
          printfn $"transformAsExpr: {expr}"
  
          match expr with
          | :? Babel.BinaryExpression as be ->
              let left, leftStmts = com.TransformAsExpr(ctx, be.Left)
              let right, rightStmts = com.TransformAsExpr(ctx, be.Right)
  
              let bin op =
                  BinOp(left, op, right).AsExpr(), leftStmts @ rightStmts
  
              let cmp op =
                  Compare(left, [ op ], [ right ]).AsExpr(), leftStmts @ rightStmts
  
              match be.Operator with
              | "+" -> Add() |> bin
  