anchor.diff:                          Assign.Create(targets, expr)
                       | None -> ()
               ]
  -        | Babel.ExpressionStatement(es) ->
  +        | Babel.ExpressionStatement { Expression=expression } ->
               // Handle Babel expressions that we need to transforme here as Python statements
  -            match es.Expression with
  +            match expression with
               | Babel.AssignmentExpression(ae) -> com.TransformAsStatements(ctx, returnStrategy, ae |> Babel.AssignmentExpression)
               | _ ->
                   [
  -                    let expr, stmts = com.TransformAsExpr(ctx, es.Expression)
  +                    let expr, stmts = com.TransformAsExpr(ctx, expression)
                       yield! stmts
                       Expr.Create(expr)
                   ]
  
positive.code:                             [ If.Create(test = test, body = body, ?orelse = ifThenElse None cases) ]
                              |> Some
  
              let result = ss.Cases |> List.ofArray |> ifThenElse None
              match result with
              | Some ifStmt -> stmts @ ifStmt
              | None -> []
  
negative.code:                 | _ -> []
  
              [ Try.Create(body = body, handlers = handlers, ?finalBody = finalBody) ]
          | Babel.SwitchStatement { Discriminant=discriminant; Cases=cases } ->
              let value, stmts = com.TransformAsExpr(ctx, discriminant)
  
              let rec ifThenElse (fallThrough: Expression option) (cases: Babel.SwitchCase list): Statement list option =
                  match cases with
  