anchor.diff:          //     oe.Properties
           | a -> failwith $"Unhandled value: {a}"
   
  -    let rec transformExprAsStatements (com: IPythonCompiler) ctx (returnStrategy: ReturnStrategy option) (expr: Babel.Expression): Statement list =
  -     match expr with
  -     | :? Babel.AssignmentExpression as ae ->
  +    /// Transform Babel expressions as Python statements.
  +    let rec transformExpressionAsStatements (com: IPythonCompiler) ctx (returnStrategy: ReturnStrategy option) (expr: Babel.Expression): Statement list =
  +        match expr with
  +        | :? Babel.AssignmentExpression as ae ->
               let value = com.TransformAsExpr(ctx, ae.Right)
               let targets: Expression list =
                   let attr =
                       match ae.Left with
  -                    | :? Babel.Identifier as identifier -> identifier.Name
  +                    | :? Babel.Identifier as identifier -> Identifier(identifier.Name)
  +                    | :? Babel.MemberExpression as me ->
  +                        match me.Property with
  +                        | :? Babel.Identifier as id -> Identifier(id.Name)
  +                        | _ -> failwith "transformExpressionAsStatements: unknown property {me.Property}"
                       | _ -> failwith $"AssignmentExpression, unknow expression: {ae.Left}"
  -                [ Attribute(value=Name(id=Identifier("self"), ctx=Load()), attr=Identifier(attr), ctx = Store()) ]
  +                [ Attribute(value=Name(id=Identifier("self"), ctx=Load()), attr=attr, ctx = Store()) ]
   
               [ Assign(targets = targets, value = value) ]
   
  -     | _ -> failwith $"transformAsStatements: unknown expr: {expr}"
  -
  -    let rec transformStmtAsStatements (com: IPythonCompiler) ctx (returnStrategy: ReturnStrategy option) (stmt: Babel.Statement): Statement list =
  +        | _ -> failwith $"transformExpressionAsStatements: unknown expr: {expr}"
  +
  +    /// Transform Babel statement as Python statements.
  +    let rec transformStatementAsStatements (com: IPythonCompiler) ctx (returnStrategy: ReturnStrategy option) (stmt: Babel.Statement): Statement list =
           match stmt with
           | :? Babel.BlockStatement as bl ->
               [ for st in bl.Body do
  
positive.code:             //         | None -> upcast Babel.NullLiteral ()
              //member _.GetAllImports() = upcast imports.Values
              member bcom.TransformAsExpr(ctx, e) = transformAsExpr bcom ctx e
              member bcom.TransformAsStatements(ctx, ret, e) = transformExprAsStatements bcom ctx ret e
              member bcom.TransformAsStatements(ctx, ret, e) = transformStmtAsStatements bcom ctx ret e
              member bcom.TransformAsClassDef(ctx, cls) = transformAsClassDef bcom ctx cls
          //member bcom.TransformFunction(ctx, name, args, body) = transformFunction bcom ctx name args body
          //member bcom.TransformImport(ctx, selector, path) = transformImport bcom ctx None selector path
  
negative.code:                 | None -> () ]
  
          | :? Babel.ExpressionStatement as es ->
              // Handle Babel expressions that needs to be transformed as Python statements
              match es.Expression with
              | :? Babel.AssignmentExpression ->
                  com.TransformAsStatements(ctx, returnStrategy, es.Expression)
              | _ ->
                  [ Expr(com.TransformAsExpr(ctx, es.Expression)) ]
  
          | _ -> failwith $"transformStatementAsStatements: Unhandled stmt: {stmt}"
  
      /// Transform Babel program to Python module.
      let transformProgram (com: IPythonCompiler) ctx (body: Babel.ModuleDeclaration array): Module =
          let returnStrategy = Some ReturnStrategy.Return
  
  