anchor.diff:          printfn $"transformStatementAsStatements: {stmt}, returnStrategy: {returnStrategy}"
   
           match stmt with
  -        | Babel.BlockStatement(bl) ->
  -            [
  -                for st in bl.Body do
  -                    yield! com.TransformAsStatements(ctx, returnStrategy, st)
  -            ]
  +        | Babel.BlockStatement(bs) ->
  +            [ yield! com.TransformAsStatements(ctx, returnStrategy, bs) ]
               |> transformBody returnStrategy
   
  -        | Babel.ReturnStatement(rtn) ->
  -            let expr, stmts = transformAsExpr com ctx rtn.Argument
  +        | Babel.ReturnStatement { Argument=arg } ->
  +            let expr, stmts = transformAsExpr com ctx arg
   
               match returnStrategy with
               | ReturnStrategy.NoReturn -> stmts @ [ Expr.Create(expr) ]
  
positive.code:         printfn $"transformExpressionAsStatements: {expr}"
  
          match expr with
          | Babel.AssignmentExpression(ae) ->
              let value, stmts = com.TransformAsExpr(ctx, ae.Right)
  
              let targets: Expression list =
                  match ae.Left with
                  | Babel.Identifier(identifier) ->
                      let target =
                          Identifier(Helpers.cleanNameAsPythonIdentifier (identifier.Name))
  
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))
  
  