anchor.diff:          let inline replace pattern (f: System.Text.RegularExpressions.Match -> string) input =
               System.Text.RegularExpressions.Regex.Replace(input, pattern, f)
   
  -        // 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 printSegment (printer: Printer) (value: string) segmentStart segmentEnd =
               let segmentLength = segmentEnd - segmentStart
               if segmentLength > 0 then
  
positive.code:                     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
  
          else
              printer.Print(value)
  
  // Template Literals
  //type TemplateElement(value: string, tail, ?loc) =
  
negative.code:     member __.ReturnType: TypeAnnotation option = returnType
      member __.TypeParameters: TypeParameterDeclaration option = typeParameters
      override _.Print(printer) =
          let body =
              match body with
              | U2.Case1 block -> block
              | U2.Case2 expr -> BlockStatement [|ReturnStatement expr|]
          printer.PrintFunction(None, ``params``, body, loc, isArrow=true)
  
  type FunctionExpression(``params``, body, ?id, ?returnType, ?typeParameters, ?loc) = //?generator_, ?async_
      inherit Expression("FunctionExpression", ?loc = loc)
  