code: function(walk) {
      var end = walk.lookahead(function(w) {
        w.skip();
        // Closing tags count
        if (w.at("/"))
          w.skip();
        // Tag name should start with latin
        if (!w.atLatin())
          return null;
        while(w.atLatin())
          w.skip();
        // Tag name skipped, now search for either /> or >
        while(w.hasCurrent()) {
          if (w.at(">")) {
            w.skip();
            return w.position;
          } else if (w.at("/>")) {
            w.skip(2);
            return w.position;
          }
          w.skip();
        }
        return null;
      });
      // Not HTML tag -- returning
      if (end === null)
        return false;
      // Emitting HTML tag
      var w = new SubWalker(walk, walk.position, end);
      while(w.hasCurrent())
        this.emitHtmlTag(w);
      walk.startFrom(end);
      return true;
    }
docs: /* HTML tags and comments are emitted without much of modification
  (only amps are processed inside). A word of a caution, though.
  
  HTML tag is rather coarsely determined: we look for `<`,
  then optional `/` (in case this is a close tag); then
  latin word -- tag name. If matching is successful up to this point,
  we start looking for the sequence which closes this tag (`>` or `/>`).
  
  This leads to unexpected behaviour, if you have an input like
  `A<B *hello* A>B`, which you would expect to compile like
  `A&lt;B <strong>hello</strong> A&gt;B`. Due to our coarse HTML detection
  the `<B *hello* A>` sequence is considered a HTML tag, thus is left
  unprocessed.
  
  Most of the time this is totally OK, however. The `<` chars are not
  encountered that much in plain texts, and when they do, they are usually:
  
  a part of MathJAX expression (inside `%%` or `$$`);
  a part of code block or code span;
  delimited from words with spaces.
  
  In all of these cases it will be escaped as `&lt;`, comme il faut.