anchor.diff:      _ = validate_docs(H,Path),
       validate_docs(T,Path);
   validate_docs({br,Attr,Content} = Br,Path) ->
  -    if Attr =:= [],
  -       Content =:= [] ->
  +    if Attr =:= [], Content =:= [] ->
               ok;
          true ->
               throw({content_to_allowed_in_br,Br,Path})
  
positive.code:                                         Doc =/= #{}
                                  end, Members) of
                    {value, {_,_,_,Doc,_Meta}} ->
                        render_docs(Signatures,get_local_doc({F,A},Doc), [], D);
                    false ->
                        case lists:keyfind(Group, 1, Docs) of
                            false ->
                                render_docs(Signatures,get_local_doc({F,A},none), [], D);
                            {_,_,_,Doc,_} ->
                                render_docs(Signatures,get_local_doc({F,A},Doc), [], D)
                        end
                end
        end, maps:to_list(Grouping)).
  
      %% [render_docs(render_signature(Func),get_local_doc({F,A},Doc,Meta,Docs), Meta, D)
      %%  || {{_,F,A},_Anno,_Sig,Doc,Meta} = Func <- lists:sort(FDocs)].
  
  %% Render the signature of either function, type, or anything else really.
  render_signature({{_Type,_F,_A},_Anno,_Sig,_Docs,#{ signature := Specs } = Meta}) ->
      lists:flatmap(fun(Spec) ->
                            [erl_pp:attribute(Spec,[{encoding,utf8}])|render_meta(Meta)]
                    end, Specs);
  render_signature({{_Type,_F,_A},_Anno,Sigs,_Docs,Meta}) ->
      lists:flatmap(fun(Sig) ->
                            [Sig|render_meta(Meta)]
                    end, Sigs).
  
  render_meta(#{ since := Vsn } = M) ->
      [[" Since: ",Vsn] | render_meta(maps:remove(since, M))];
  render_meta(#{ deprecated := Depr }) ->
      [[" Deprecated: ",Depr]];
  render_meta(_) ->
      [].
  
  render_docs(Headers, DocContents, _MD, D = #config{}) ->
      init_ansi(D),
      try
          {Doc,_} = trimnl(render_docs(DocContents,[],0,2,D)),
          [sansi(bold),
           [io_lib:format("~n~ts",[Header]) || Header <- Headers],
           ransi(bold),
           io_lib:format("~n~n~ts",[Doc])]
      after
          clean_ansi()
      end;
  render_docs(Headers, DocContents, MD, D) ->
      render_docs(Headers, DocContents, MD, #config{ docs = D }).
  
  %%% Functions for rendering type/callback documentation
  render_signature_listing(Module, Description, TypeOrCBs, D = #config{}) ->
      init_ansi(D),
      try
          [sansi(bold),"\t",atom_to_list(Module),ransi(bold),"\n\n",
           Description,"\n",
           [ io_lib:format("~n~ts",[Header]) || Headers <- lists:flatmap(fun render_signature/1, TypeOrCBs), Header <- Headers]]
      after
          clean_ansi()
      end;
  render_signature_listing(Module, Description, TypeOrCBs, D) ->
      render_signature_listing(Module, Description, TypeOrCBs, #config{ docs = D }).
  
  render_typecb_docs([], _D) ->
      {error,type_missing};
  render_typecb_docs(TypeCBs, #config{} = D) when is_list(TypeCBs) ->
      [render_typecb_docs(TypeCB, D) || TypeCB <- TypeCBs];
  render_typecb_docs({{_,F,A},_,_Sig,Docs,Meta} = TypeCB, #config{} = D) ->
      render_docs(render_signature(TypeCB), get_local_doc({F,A},Docs), Meta, D);
  render_typecb_docs(Docs, D) ->
      render_typecb_docs(Docs, #config{ docs = D }).
  
  %%% General rendering functions
  render_docs(Elems,State,Pos,Ind,D) when is_list(Elems) ->
      lists:mapfoldl(fun(Elem,P) ->
  %                           io:format("Elem: ~p (~p) (~p,~p)~n",[Elem,State,P,Ind]),
  
negative.code:     [{F,A,S,get_local_doc(F, D),M} || {F,A,S,D,M} <- FnFunctions].
  
  -spec render_type(Module :: module(), Docs :: docs_v1()) -> unicode:chardata().
  render_type(Module, D) ->
      render_signature_listing(Module, type, D).
  
  -spec render_type(Module :: module(), Type :: atom(), Docs :: docs_v1()) ->
            unicode:chardata() | {error,type_missing}.
  