anchor.diff:                      yield! stmts
                       Expr.Create(expr)
                   ]
  -        | Babel.IfStatement(iff) ->
  -            let test, stmts = com.TransformAsExpr(ctx, iff.Test)
  +        | Babel.IfStatement { Test=test; Consequent=consequent; Alternate=alternate } ->
  +            let test, stmts = com.TransformAsExpr(ctx, test)
   
               let body =
  -                com.TransformAsStatements(ctx, returnStrategy, iff.Consequent)
  +                com.TransformAsStatements(ctx, returnStrategy, consequent)
                   |> transformBody ReturnStrategy.NoReturn
   
               let orElse =
  -                match iff.Alternate with
  +                match alternate with
                   | Some alt ->
                       com.TransformAsStatements(ctx, returnStrategy, alt)
                       |> transformBody ReturnStrategy.NoReturn
  
positive.code:         printfn $"transformStatementAsStatements: {stmt}, returnStrategy: {returnStrategy}"
  
          match stmt with
          | Babel.BlockStatement(bl) ->
              [
                  for st in bl.Body do
                      yield! com.TransformAsStatements(ctx, returnStrategy, st)
              ]
              |> transformBody returnStrategy
  
          | Babel.ReturnStatement(rtn) ->
              let expr, stmts = transformAsExpr com ctx rtn.Argument
  
              match returnStrategy with
              | ReturnStrategy.NoReturn -> stmts @ [ Expr.Create(expr) ]
  
negative.code:                     | _ -> value
  
                  Attribute.Create(value = value, attr = attr, ctx = Load), stmts
          | Babel.Literal(Babel.BooleanLiteral { Value=value }) -> Constant.Create(value = value), []
          | Babel.FunctionExpression(fe) ->
              let args =
                  fe.Params
  