anchor.diff:                      | _ -> value
   
                   Attribute.Create(value = value, attr = attr, ctx = Load), stmts
  -        | Babel.Literal(Babel.BooleanLiteral(bl)) -> Constant.Create(value = bl.Value), []
  +        | Babel.Literal(Babel.BooleanLiteral { Value=value }) -> Constant.Create(value = value), []
           | Babel.FunctionExpression(fe) ->
               let args =
                   fe.Params
  
positive.code:                     yield! stmts
                      Expr.Create(expr)
                  ]
          | Babel.IfStatement(iff) ->
              let test, stmts = com.TransformAsExpr(ctx, iff.Test)
  
              let body =
                  com.TransformAsStatements(ctx, returnStrategy, iff.Consequent)
                  |> transformBody ReturnStrategy.NoReturn
  
              let orElse =
                  match iff.Alternate with
                  | Some alt ->
                      com.TransformAsStatements(ctx, returnStrategy, alt)
                      |> transformBody ReturnStrategy.NoReturn
  
negative.code:         printfn $"transformExpressionAsStatements: {expr}"
  
          match expr with
          | Babel.AssignmentExpression { Left=left; Right=right } ->
              let value, stmts = com.TransformAsExpr(ctx, right)
  
              let targets: Expression list =
                  match left with
                  | Babel.Identifier(identifier) ->
                      let target =
                          Identifier(Helpers.cleanNameAsPythonIdentifier (identifier.Name))
  