anchor.diff:          new (writer: TextWriter) =
               new Writer (new HtmlTextWriter(writer))
   
  -        // Renders an element without content and with self 
  +        // Renders an element without content and with self
           // closing tagE.g. <img class="c" />
           member private this.RenderElementWithSelfClosingTag name (attrs: list<Attribute<'T>>) =
               writer.WriteBeginTag(name)
  
positive.code:                     |> List.map (fun content -> content.CollectAnnotations())
                      |> List.concat
                  match content.Annotation with
                  | Some a    -> [a]
                  | None      -> []
                  |> List.append nested
              | TextContent _
              | VerbatimContent _
              | CommentContent _ ->
                  []
  
      /// Constructs a new HTML element.
      let NewElement (name: string) (elements: seq<#INode<'T>>) =
  
negative.code:     type Document<'T> =
          {
              Annotations : Map<Id,'T>
              Body : Element<unit>
          }
  
      /// Resolves the annotations by giving them HTML identifiers. The function
      /// `isUsed` tests if a given identifier should not be used by the document.
      let Resolve (isUsed: Id -> bool) (document: TagContent<'T>) =
          let ids = Dictionary<Id,unit>()
          let annotations = Dictionary<Id,'T>()
          let showId (k: int) = String.Format("id{0:x}", k)
          let newId () =
              let mutable k  = ids.Count
              let mutable id = showId k
              while ids.ContainsKey id || isUsed id do
                  k <- k + 1
                  id <- showId k
              ids.[id] <- ()
              id
          let rec transform (element: TagContent<'T>) =
              let mutable attributes = []
              let mutable id = None
              for x in element.Attributes do
                  match x.Name.ToLower() with
                  | "id" -> ids.[x.Value] <- (); id <- Some x.Value
                  | _ -> ()
                  let attribute = { Name = x.Name; Value = x.Value }
                  attributes <- attribute :: attributes
              match element.Annotation with
              | None -> ()
              | Some a ->
                  let id =
                      match id with
                      | Some id   -> id
  