anchor.diff:                      if i < subSegments.Length then
                           printer.PrintNewLine()
   
  -        let matches = System.Text.RegularExpressions.Regex.Matches(value, @"\$\d+")
  -        if matches.Count > 0 then
  -                for i = 0 to matches.Count - 1 do
  -                    let m = matches.[i]
  -
  -                    let segmentStart =
  -                        if i > 0 then matches.[i-1].Index + matches.[i-1].Length
  -                        else 0
  -
  -                    printSegment printer value segmentStart m.Index
  -
  -                    let argIndex = int m.Value.[1..]
  -                    match Array.tryItem argIndex args with
  -                    | Some e -> printer.MaybeWithParens(e)
  -                    | None -> printer.Print("(void \"missing\")")
  -
  -                let lastMatch = matches.[matches.Count - 1]
  -                printSegment printer value (lastMatch.Index + lastMatch.Length) value.Length
  -
  +        if args.Length = 0 then
  +            printSegment printer value 0 value.Length
           else
  -            printer.Print(value)
  +            // Macro transformations
  +            // https://fable.io/docs/communicate/js-from-fable.html#Emit-when-F-is-not-enough
  +            let value =
  +                value
  +                |> replace @"\$(\d+)\.\.\." (fun m ->
  +                    let rep = ResizeArray()
  +                    let i = int m.Groups.[1].Value
  +                    for j = i to args.Length - 1 do
  +                        rep.Add("$" + string j)
  +                    String.concat ", " rep)
  +
  +                |> replace @"\{\{\s*\$(\d+)\s*\?(.*?)\:(.*?)\}\}" (fun m ->
  +                    let i = int m.Groups.[1].Value
  +                    match args.[i] with
  +                    | :? BooleanLiteral as b when b.Value -> m.Groups.[2].Value
  +                    | _ -> m.Groups.[3].Value)
  +
  +                |> replace @"\{\{([^\}]*\$(\d+).*?)\}\}" (fun m ->
  +                    let i = int m.Groups.[2].Value
  +                    match Array.tryItem i args with
  +                    | Some _ -> m.Groups.[1].Value
  +                    | None -> "")
  +
  +                // This is to emit string literals as JS, I think it's no really
  +                // used and it shouldn't be necessary with the new emitJsExpr
  +    //            |> replace @"\$(\d+)!" (fun m ->
  +    //                let i = int m.Groups.[1].Value
  +    //                match Array.tryItem i args with
  +    //                | Some(:? StringLiteral as s) -> s.Value
  +    //                | _ -> "")
  +
  +            let matches = System.Text.RegularExpressions.Regex.Matches(value, @"\$\d+")
  +            if matches.Count > 0 then
  +                    for i = 0 to matches.Count - 1 do
  +                        let m = matches.[i]
  +
  +                        let segmentStart =
  +                            if i > 0 then matches.[i-1].Index + matches.[i-1].Length
  +                            else 0
  +
  +                        printSegment printer value segmentStart m.Index
  +
  +                        let argIndex = int m.Value.[1..]
  +                        match Array.tryItem argIndex args with
  +                        | Some e -> printer.MaybeWithParens(e)
  +                        | None -> printer.Print("(void \"missing\")")
  +
  +                    let lastMatch = matches.[matches.Count - 1]
  +                    printSegment printer value (lastMatch.Index + lastMatch.Length) value.Length
  +
  +            else
  +                printer.Print(value)
   
   // Template Literals
   //type TemplateElement(value: string, tail, ?loc) =
  
positive.code:     member __.ReturnType: TypeAnnotation option = returnType
      member __.TypeParameters: TypeParameterDeclaration option = typeParameters
      override _.Print(printer) =
          // TODO: type annotations
          // TODO: Remove parens if we only have one argument (and no annotation)
          printer.Print("(", ?loc=loc)
          printer.PrintCommaSeparatedArray(``params``)
          printer.Print(") => ")
          match body with
          | U2.Case1 block ->
              match block.Body with
              | [|:? ReturnStatement as r |] -> r.Argument.Print(printer)
              | _ -> printer.PrintBlock(block.Body, skipNewLineAtEnd=true)
          | U2.Case2 expr -> expr.Print(printer)
  
  type FunctionExpression(``params``, body, ?id, ?returnType, ?typeParameters, ?loc) = //?generator_, ?async_
      inherit Expression("FunctionExpression", ?loc = loc)
  
negative.code:             body.Print(printer)
  
          // TODO: type annotations
          member printer.PrintFunction(id: Identifier option, parameters: Pattern array, body: BlockStatement, loc, ?isArrow) =
              let isArrow = defaultArg isArrow false
              printer.AddLocation(loc)
  
              // Check if we can remove the function
              let skipExpr =
                  match body.Body with
                  | [|:? ReturnStatement as r|] ->
                      match r.Argument with
                      | :? CallExpression as c when parameters.Length = c.Arguments.Length ->
                          Array.zip parameters c.Arguments
                          |> Array.forall (function
                              | U2.Case2(:? Identifier as p), (:? Identifier as a) -> p.Name = a.Name
                              | _ -> false)
                          |> function true -> Some(c.Callee) | false -> None
                      | _ -> None
                  | _ -> None
  
              match skipExpr with
              | Some e -> e.Print(printer)
              | None ->
                  if isArrow then
                      // TODO: Remove parens if we only have one argument (and no annotation)
                      printer.Print("(")
                      printer.PrintCommaSeparatedArray(parameters)
                      printer.Print(") => ")
                      match body.Body with
                      | [|:? ReturnStatement as r |] -> r.Argument.Print(printer)
                      | _ -> printer.PrintBlock(body.Body, skipNewLineAtEnd=true)
                  else
                  printer.Print("function ")
                  printer.PrintOptional(id)
                  printer.Print("(")
                  printer.PrintCommaSeparatedArray(parameters)
                  printer.Print(") ")
                  printer.PrintBlock(body.Body, skipNewLineAtEnd=true)
  
          member printer.MaybeWithParens(expr: Expression) =
              match expr with
  