anchor.diff:              | "void $0" -> args.[0], stmts
               //| "raise %0" -> Raise.Create()
               | _ -> Emit.Create(value, args), stmts
  -        | Babel.MemberExpression(me) ->
  -            let value, stmts = com.TransformAsExpr(ctx, me.Object)
  -
  -            if me.Computed then
  +        | Babel.MemberExpression { Computed=computed; Object=object; Property=property } ->
  +            let value, stmts = com.TransformAsExpr(ctx, object)
  +
  +            if computed then
                   let attr =
  -                    match me.Property with
  +                    match property with
                       | Babel.Literal(Babel.NumericLiteral(nl)) -> Constant.Create(nl.Value)
                       | Babel.Literal(Babel.StringLiteral(literal)) -> Constant.Create(literal.Value)
  -                    | _ -> failwith $"transformExpressionAsStatements: unknown property {me.Property}"
  +                    | _ -> failwith $"transformExpressionAsStatements: unknown property {property}"
   
                   Subscript.Create(value = value, slice = attr, ctx = Load), stmts
               else
                   let attr =
  -                    match me.Property with
  +                    match property with
                       | Babel.Identifier { Name=name } -> Identifier(name)
  -                    | _ -> failwith $"transformExpressionAsStatements: unknown property {me.Property}"
  +                    | _ -> failwith $"transformExpressionAsStatements: unknown property {property}"
   
                   let value =
                       match value with
  
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:         (com: IPythonCompiler)
          (ctx: Context)
          (returnStrategy: ReturnStrategy)
          (block: Babel.BlockStatement)
          : list<Statement> =
  
          [ for stmt in block.Body do
              yield! transformStatementAsStatements com ctx returnStrategy stmt ]
  
      /// Transform Babel program to Python module.
      let transformProgram (com: IPythonCompiler) ctx (body: Babel.ModuleDeclaration array): Module =
  