anchor.diff:          )
       | S.If (a, b, c) -> If (trE a, trS b, trS c)
       | S.Ignore a -> ExprStatement (trE a)    
  -    | S.Labelled (a, b)  -> failwith "TODO: recognize labels"
  +    | S.Labelled (a, b)  -> 
  +        failwith "Currently unsupported: JS labels"
       | S.Return a -> Return (match a with Some v -> trE v | _ -> Undefined)
  -    | S.Switch (a, b)    -> failwith "TODO: recognize switch"
  +    | S.Switch (a, b) -> 
  +        Switch(trE a, b |> List.map (function 
  +            | S.Case (c, cs) -> Some (trE c), Block (cs |> List.map trS) 
  +            | S.Default d -> None, Block (d |> List.map trS)
  +        ))
       | S.Throw a -> Throw (trE a)
       | S.TryFinally (a, b) -> TryFinally (trS a, trS b)
  -    | S.TryWith (a, b, c, d)   -> failwith "TODO: recognize try-with"
  +    | S.TryWith (a, b, c, d) -> 
  +        let tw = TryWith (trS a, Some (env.NewVar b), trS c)
  +        match d with
  +        | None -> tw
  +        | Some d -> TryFinally (tw, trS d)
       | S.Vars a ->
           match a with
           | [var, value] -> 
  
positive.code:         a |> List.map trS |> CombineStatements
      | S.Break a   -> Break (a |> Option.map (fun l -> env.Labels.[l]))
      | S.Continue a -> Continue (a |> Option.map (fun l -> env.Labels.[l]))
      | S.Debugger -> failwith "TODO"
      | S.Do (a, b) -> DoWhile (trS a, trE b)
      | S.Empty -> Empty
      | S.For (a, b, c, d) -> 
          For (Option.map trE a, Option.map trE b, Option.map trE c, trS d) // TODO: var declarations (?)
      | S.ForIn (a, b, c) -> failwith "TODO" //
      | S.ForVarIn (a, b, c, d) -> 
          match b with
          | Some b -> failwith "TODO"
          | _ ->
          let v = env.NewVar a
          Block [
              VarDeclaration (v, Undefined)
              ForIn(v, trE c, trS d)
          ]
      | S.ForVars (a, b, c, d) -> 
  
negative.code:             e |> transformExpression (Environment.New(thisArg, false, isPure, args))
          | Choice2Of2 p ->
              p
              |> List.map (function S.Action a -> a | _ -> failwith "Currently unsupported: function declarations in Inline" )
              |> S.Block
              |> transformStatement (Environment.New(thisArg, false, isPure, args))
              |> IgnoredStatementExpr
  