anchor.diff:      /// Immediately Invoked LambdaType Expression
       let iife (com: IBabelCompiler) ctx (expr: Fable.Expr) =
           let _, body = com.TransformFunction ctx None [] expr
  -        CallExpression(ArrowFunctionExpression ([], body, ?loc=expr.Range), [], ?loc=expr.Range)
  +        CallExpression(ArrowFunctionExpression ([], body), [])
   
       let varDeclaration range (var: Pattern) (isMutable: bool) value =
           let kind = if isMutable then Let else Const
  
positive.code:             "Unresolved call detected in Babel pass"
              |> addErrorAndReturnNull com ctx.file.SourcePath range
  
      let block r statements =
          BlockStatement(statements, ?loc=r)
  
      // When expecting a block, it's usually not necessary to wrap it
      // in a lambda to isolate its variable context
      let transformBlock (com: IBabelCompiler) ctx ret expr: BlockStatement =
          match ret with
          | None -> com.TransformStatement ctx expr |> block expr.Range
          | Some ret -> com.TransformExprAndResolve ctx ret expr |> block expr.Range
  
      let transformSwitch (com: IBabelCompiler) ctx returnStrategy (matchValue, cases, defaultCase) =
          let transformCase test branch =
  
negative.code:             match expr with
              | :? ClassExpression as e ->
                  upcast ClassDeclaration(e.body, privateIdent,
                      ?super=e.superClass, ?typeParams=e.typeParameters)
              | :? FunctionExpression as e ->
                  upcast FunctionDeclaration(privateIdent, e.``params``, e.body)
              | _ -> upcast varDeclaration range privateIdent isMutable expr
          if not isPublic then
              U2.Case1 (decl :> Statement) |> List.singleton
  