anchor.diff:              Tuple.Create(elems), stmts
           | Babel.Literal(Babel.NumericLiteral(nl)) -> Constant.Create(value = nl.Value), []
           | Babel.Literal(Babel.StringLiteral(sl)) -> Constant.Create(value = sl.Value), []
  -        // | Babel.Pattern(Babel.IdentifierPattern { Name=name }) ->
  -        //     let name = Helpers.cleanNameAsPythonIdentifier name
  -        //     Name.Create(id = Identifier name, ctx = Load), []
  -        | Babel.NewExpression(ne) -> // FIXME: use transformAsCall
  -            let func, stmts = com.TransformAsExpr(ctx, ne.Callee)
  +        | Babel.Identifier { Name=name } ->
  +            let name = Helpers.cleanNameAsPythonIdentifier name
  +            Name.Create(id = Identifier name, ctx = Load), []
  +        | Babel.NewExpression { Callee=callee; Arguments=args} -> // FIXME: use transformAsCall
  +            let func, stmts = com.TransformAsExpr(ctx, callee)
   
               let args, stmtArgs =
  -                ne.Arguments
  +                args
                   |> List.ofArray
                   |> List.map (fun arg -> com.TransformAsExpr(ctx, arg))
                   |> Helpers.unzipArgs
   
               Call.Create(func, args), stmts @ stmtArgs
           | Babel.Super(se) -> Name.Create(Identifier("super().__init__"), ctx = Load), []
  -        | Babel.ObjectExpression({Properties=properties}) ->
  +        | Babel.ObjectExpression { Properties=properties } ->
               let keys, values, stmts =
                   [
                       for prop in properties do
  
positive.code:                     | _ -> args
                  Arguments.Create(args = args)
  
              let stmts = afe.Body.Body // TODO: Babel AST should be fixed. Body does not have to be a BlockStatement.
              match stmts with
              | [| Babel.ReturnStatement(rtn) |] ->
                  let body, stmts = com.TransformAsExpr(ctx, rtn.Argument)
                  Lambda.Create(arguments, body), stmts
              | _ ->
                  let body =
                      com.TransformAsStatements(ctx, ReturnStrategy.Return, afe.Body)
  
                  let name = Helpers.getIdentifier "lifted"
  
                  let func =
  
negative.code:                 // TODO: Should be Contant(value=None) but we cannot create that in F#
                  Name.Create(id = Identifier("None"), ctx = Load), stmts
  
          | Babel.ArrowFunctionExpression { Params=parms; Body=body} ->
              let args =
                  parms
                  |> List.ofArray
                  |> List.map (fun pattern -> Arg.Create(Identifier pattern.Name))
  
  