/* dbl_emphas */ (int(*)(Blob*,Blob*,char,void*))mkdn_noop1,
    /* emphasis   */ (int(*)(Blob*,Blob*,char,void*))mkdn_noop1,
    /* image      */ (int(*)(Blob*,Blob*,Blob*,Blob*,void*))mkdn_noop1,
    /* linebreak  */ (int(*)(Blob*,void*))mkdn_noop1,
    /* link       */ backlink_md_link,
    /* r_html_tag */ (int(*)(Blob*,Blob*,void*))mkdn_noop1,
    /* tri_emphas */ (int(*)(Blob*,Blob*,char,void*))mkdn_noop1,
    /* footnoteref*/ (int(*)(Blob*,const Blob*,int,int,void*))mkdn_noop1,

    0,  /* entity */
    0,  /* normal_text */
    "*_", /* emphasis characters */
    0   /* client data */
  };
  Blob out, in;

  font-weight: bold;
}
div.markdown > ol.footnotes > li > .footnote-backrefs > a:target {
  background: gold;
}
div.markdown a.noteref:target > sup {
  background: gold;
}
div.markdown span.notescope:target {
  border-bottom: 2px solid gold;
}
div.markdown span.notescope:target > a.noteref > sup {
  background: gold;
}

/* Objects in the "desktoponly" class are invisible on mobile */
@media screen and (max-width: 600px) {
  .desktoponly {
    display: none;
  }

            struct Blob *alt, void *opaque);
  int (*linebreak)(struct Blob *ob, void *opaque);
  int (*link)(struct Blob *ob, struct Blob *link, struct Blob *title,
          struct Blob *content, void *opaque);
  int (*raw_html_tag)(struct Blob *ob, struct Blob *tag, void *opaque);
  int (*triple_emphasis)(struct Blob *ob, struct Blob *text,
            char c, void *opaque);
  int (*footnote_ref)(struct Blob *ob, const struct Blob *span,
                      int index, int locus, void *opaque);

  /* low level callbacks - NULL copies input directly into the output */
  void (*entity)(struct Blob *ob, struct Blob *entity, void *opaque);
  void (*normal_text)(struct Blob *ob, struct Blob *text, void *opaque);

  /* renderer data */
  const char *emph_chars; /* chars that trigger emphasis rendering */

  fn->nUsed++;
  assert( fn->index > 0 );
  assert( fn->nUsed > 0 );
cleanup:
  release_work_buffer( rndr, id );
  return fn;
}
/* Adds unlabeled footnote to the rndr.
 * If text is blank then returns 0,
 * otherwise returns the address of the added footnote. */
static inline const struct footnote* add_inline_footnote(
  struct render *rndr,
  const char *text,
  size_t size
){
  struct footnote fn = { empty_blob, empty_blob, 0, 0 };
  while(size && (*text==' ' || *text=='\t')){ text++; size--; }
  if(!size) return 0;
  fn.index = ++(rndr->iNotesCount);
  fn.nUsed = 1;
  assert( fn.index > 0 );
  blob_append(&fn.text, text, size);
  blob_append(&rndr->notes, (char *)&fn, sizeof fn);
  return (struct footnote*)( blob_buffer(&rndr->notes)
                            +( blob_size(&rndr->notes)-sizeof fn ));
}

/* Return the offset of the matching closing bracket or 0 if not found.
 * begin[0] must be either '[' or '('          */
static inline size_t matching_bracket_offset(
  const char* begin,
  const char* end
){
  const char *i;
  int level;
  const char bra = *begin;
  const char ket = bra=='[' ? ']' : ')';
  assert( bra=='[' || bra=='(' );      /* FIXME: only when debugging */
  for(i=begin+1,level=1; i!=end; i++){
    if( *i=='\n' )        /* do nothing */;
    else if( i[-1]=='\\' ) continue;   /* ? FIXME: what if \\( ? */
    else if( *i==bra )     level++;
    else if( *i==ket ){
      if( --level<=0 ) return i-begin;
    }
  }
  return 0;
}

/* char_footnote -- '(': parsing a standalone inline footnote */
static size_t char_footnote(
  struct Blob *ob,
  struct render *rndr,
  char *data,
  size_t offset,
  size_t size
){
  size_t end;
  const struct footnote* fn;

  if( size<4 || data[1]!='^' || !rndr->make.footnote_ref ) return 0;
  end = matching_bracket_offset(data, data+size);
  if( !end ) return 0;
  fn = add_inline_footnote(rndr, data+2, end-2);
  if(fn) rndr->make.footnote_ref(ob,0,fn->index,1,rndr->make.opaque);
  return end+1;
}

/* char_link -- '[': parsing a link or an image */
static size_t char_link(
  struct Blob *ob,
  struct render *rndr,
  char *data,
  size_t offset,

  /* allocate temporary buffers to store content, link and title */
  title = new_work_buffer(rndr);
  content = new_work_buffer(rndr);
  link = new_work_buffer(rndr);
  ret = 0; /* error if we don't get to the callback */

  /* inline style link or span-bounded inline footnote */
  if( i<size && data[i]=='(' ){

    /* inline footnote */
    if( i+2<size && data[i+1]=='^' ){

      const size_t k = matching_bracket_offset(data+i, data+size);
      if( !k ) goto char_link_cleanup;
      fn = add_inline_footnote(rndr, data+(i+2), k-2);
      i += k+1;
    }else{
      size_t span_end = i;
      while( span_end<size
       && !(data[span_end]==')' && (span_end==i || data[span_end-1]!='\\'))
      ){
        span_end++;
      }

      if( span_end>=size
       || get_link_inline(link, title, data+i+1, span_end-(i+1))<0
      ){
        goto char_link_cleanup;
      }

      i = span_end+1;
    }

  /* reference style link or span-bounded footnote reference */
  }else if( i<size && data[i]=='[' ){
    char *id_data;
    size_t id_size, id_end = i;
    int bFootnote;

    while( id_end<size && data[id_end]!=']' ){ id_end++; }

    if( id_end>=size ) goto char_link_cleanup;
    bFootnote = data[i+1]=='^';

    if( i+1==id_end || (bFootnote && i+2==id_end) ){
      /* implicit id - use the contents */
      id_data = data+1;
      id_size = txt_e-1;
    }else{
      /* explicit id - between brackets */
      id_data = data+i+1;
      id_size = id_end-(i+1);
      if( bFootnote ){
        id_data++;
        id_size--;
      }
    }

    if( bFootnote ){
      fn = get_footnote(rndr, id_data, id_size);
      if( !fn ) goto char_link_cleanup;
    }else if( get_link_ref(rndr, link, title, id_data, id_size)<0 ){
      goto char_link_cleanup;
    }

    i = id_end+1;

  /* shortcut reference style link or free-standing footnote refernece */
  }else{










    if(!is_img && size>3 && data[1]=='^'){

      /* free-standing footnote reference */
      fn = get_footnote(rndr, data+2, txt_e-2);
      if( !fn ) goto char_link_cleanup;
      release_work_buffer(rndr, content);
      content = 0; 
    }else if( get_link_ref(rndr, link, title, data+1, txt_e-1)<0 ){
      goto char_link_cleanup;
    }

    /* rewinding a closing square bracket */
    i = txt_e+1;
  }

  /* building content: img alt is escaped, link content is parsed */
  if( txt_e>1 && content ){
    if( is_img ) blob_append(content, data+1, txt_e-1);
    else parse_inline(content, rndr, data+1, txt_e-1);
  }

  /* calling the relevant rendering function */
  if( is_img ){
    if( blob_size(ob)>0 && blob_buffer(ob)[blob_size(ob)-1]=='!' ) ob->nUsed--;
    ret = rndr->make.image(ob, link, title, content, rndr->make.opaque);
  }else if(fn){


    if(rndr->make.footnote_ref){
      ret = rndr->make.footnote_ref(ob, content, fn->index, fn->nUsed,
                                    rndr->make.opaque);
    }
  }else{
    ret = rndr->make.link(ob, link, title, content, rndr->make.opaque);
  }

  /* cleanup */
char_link_cleanup:

  if( beg+5>=end ) return 0;
  i = beg;

  /* footnote definition must start at the begining of a line */
  if( data[i]!='[' ) return 0;
  i++;
  if( data[i]!='^' ) return 0;
  id_offset = ++i;

  /* id part: anything but a newline between brackets */
  while( i<end && data[i]!=']' && data[i]!='\n' && data[i]!='\r' ){ i++; }
  if( i>=end || data[i]!=']' ) return 0;
  id_end = i++;

  /* spacer: colon (space | tab)* */

    for(i=0; rndr.make.emph_chars[i]; i++){
      rndr.active_char[(unsigned char)rndr.make.emph_chars[i]] = char_emphasis;
    }
  }
  if( rndr.make.codespan ) rndr.active_char['`'] = char_codespan;
  if( rndr.make.linebreak ) rndr.active_char['\n'] = char_linebreak;
  if( rndr.make.image || rndr.make.link ) rndr.active_char['['] = char_link;
  if( rndr.make.footnote_ref ) rndr.active_char['('] = char_footnote;
  rndr.active_char['<'] = char_langle_tag;
  rndr.active_char['\\'] = char_escape;
  rndr.active_char['&'] = char_entity;

  /* first pass: iterate over lines looking for references,
   * copying everything else into "text" */
  beg = 0;

> Formatted using [Pikchr](https://pikchr.org/home), resulting in:

>
~~~ pikchr
oval "Start" fit; arrow; box "Hello, World!" fit; arrow; oval "Done" fit
~~~

<a id="ftnts"></a>
## Footnotes ##

> Footnotes (or "endnotes") is a Fossil's extention of classical Markdown.
> Fossil's syntax for footnotes is similar to links and
> is distinguished by the use of character **^**
> that *immediately* follows an opening bracket.

> 1. **\(^** footnote's text **)**
> 2. **\[** fragment of text **]\(^** a comment about that fragment **\)**
> 3. **\[^**&nbsp;label&nbsp;**\]**
> 4. **\[** fragment of text **\]\[^**&nbsp;label&nbsp;**\]**
> 5. **\[** fragment of text **\]\[^\]**

> With formats 1 and 2 ("inline footnotes") text of a footnote is provided
> in the place where the corresponding numeric mark will be rendered.
> With formats 3, 4, and 5 ("reference footnotes") text of a footnote
> is supplied elsewhere in the document, as shown below.
> Formats 2, 4 and 5 ("span-specific footnotes") mark a specific fragment
> that is being commented in the footnote.
> Format 5 reuses a fragment of text as a label.
> Labels are case-insensitive.

>
```
[^label]: Footnote definition must start on the first column.
      The second line (if any) must be indented by two or more spaces.
      Definition continues until indentation drops below that of the 2nd line.
```
> Charachter **^** is not part of a label, it is part of the syntax.
> Both a footnote's text and a fragment to which a footnote applies
> are subject to further interpretation as Markdown sources.

## Miscellaneous ##

> *   In-line images are made using **\!\[alt-text\]\(image-URL\)**.
> *   Use HTML for advanced formatting such as forms.
> *   **\<!--** HTML-style comments **-->** are supported.
> *   Escape special characters (ex: **\[** **\(** **\|** **\***)
>     using backslash (ex: **\\\[** **\\\(** **\\\|** **\\\***).

){
  BLOB_APPEND_LITERAL(ob, "  <tr>\n");
  BLOB_APPEND_BLOB(ob, cells);
  BLOB_APPEND_LITERAL(ob, "  </tr>\n");
}

static int html_footnote_ref(
  struct Blob *ob, const struct Blob *span, int index, int locus, void *opaque
){
  const struct MarkdownToHtml *ctx = (struct MarkdownToHtml*)opaque;
  const bitfield64_t l = to_base26(locus-1,0);
  char pos[32];

  /* expect BUGs if the following yields compiler warnings */
  memset(pos,0,32);
  sprintf(pos, "%s%i-%s", ctx->unique.c, index, l.c);
  if(span && blob_size(span)) {
    BLOB_APPEND_LITERAL(ob,"<span class='notescope' id='noteref-");
    blob_appendf(ob,"%s'>",pos);
    BLOB_APPEND_BLOB(ob, span);
    blob_trim(ob);
    BLOB_APPEND_LITERAL(ob,"<a class='noteref' href='#footnote-");
    blob_appendf(ob,"%s'><sup>%i</sup></a></span>", pos, index);
  }else{
    blob_trim(ob);
    BLOB_APPEND_LITERAL(ob,"<a class='noteref' href='#footnote-");
    blob_appendf(ob,"%s' id='noteref-%s'><sup>%i</sup></a>",
                    pos,            pos,   index);
  }
  return 1;
}

/* Render a single item of the footnotes list.
 * Each backref gets a unique id to enable dynamic styling. */
static void html_footnote_item(
  struct Blob *ob, const struct Blob *text, int index, int nUsed, void *opaque