nokogumbo 1.4.1 → 1.4.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cf20dd502d8ec6022f2c72193bb0c9a908251088
+  data.tar.gz: 326f85766d0e4f97683f5df026f08f4dc33806e8
+SHA512:
+  metadata.gz: 800800652a5260bf54399e8cca1fc6e63f7ef53aea489245c5315b6e955b38aa4dfc6d7272b99898ab78150464640ac14c995aa38b9c77644dab5d73fc0e46a5
+  data.tar.gz: 18ba647671103cfc2853a88935fe91eb965d1e6fbe1aad981438297a5035ec222b5ae6c5ed3ef127429c8b58edd02a6a5a877ba7e7ec3390d05779f7420f1521

data/ext/nokogumboc/nokogumbo.c

@@ -157,7 +157,7 @@ static xmlNodePtr walk_tree(xmlDocPtr document, GumboElement *node) {
 
     switch (child->type) {
       case GUMBO_NODE_ELEMENT:
-      case GUMBO_NODE_TEMPLATE:
+//    case GUMBO_NODE_TEMPLATE: /* future */
         node = walk_tree(document, &child->v.element);
         break;
       case GUMBO_NODE_WHITESPACE:

data/gumbo-parser/src/error.c

@@ -35,11 +35,10 @@ static const size_t kMessageBufferSize = 256;
 static int print_message(GumboParser* parser, GumboStringBuffer* output,
                          const char* format, ...) {
   va_list args;
-  int remaining_capacity = output->capacity - output->length;
   va_start(args, format);
+  int remaining_capacity = output->capacity - output->length;
   int bytes_written = vsnprintf(output->data + output->length,
                                 remaining_capacity, format, args);
-  va_end(args);
 #ifdef _MSC_VER
   if (bytes_written == -1) {
     // vsnprintf returns -1 on MSVC++ if there's not enough capacity, instead of
@@ -48,7 +47,6 @@ static int print_message(GumboParser* parser, GumboStringBuffer* output,
     // we retry (letting it fail and returning 0 if it doesn't), since there's
     // no way to smartly resize the buffer.
     gumbo_string_buffer_reserve(parser, output->capacity * 2, output);
-    va_start(args, format);
     int result = vsnprintf(output->data + output->length,
                            remaining_capacity, format, args);
     va_end(args);
@@ -57,6 +55,7 @@ static int print_message(GumboParser* parser, GumboStringBuffer* output,
 #else
   // -1 in standard C99 indicates an encoding error.  Return 0 and do nothing.
   if (bytes_written == -1) {
+    va_end(args);
     return 0;
   }
 #endif
@@ -65,12 +64,11 @@ static int print_message(GumboParser* parser, GumboStringBuffer* output,
     gumbo_string_buffer_reserve(
         parser, output->capacity + bytes_written, output);
     remaining_capacity = output->capacity - output->length;
-    va_start(args, format);
     bytes_written = vsnprintf(output->data + output->length,
                               remaining_capacity, format, args);
-    va_end(args);
   }
   output->length += bytes_written;
+  va_end(args);
   return bytes_written;
 }
 

data/gumbo-parser/src/gumbo.h

@@ -141,7 +141,7 @@ extern const GumboVector kGumboEmptyVector;
  * Returns the first index at which an element appears in this vector (testing
  * by pointer equality), or -1 if it never does.
  */
-int gumbo_vector_index_of(GumboVector* vector, const void* element);
+int gumbo_vector_index_of(GumboVector* vector, void* element);
 
 
 /**
@@ -157,10 +157,172 @@ int gumbo_vector_index_of(GumboVector* vector, const void* element);
  * strings.
  */
 typedef enum {
-  // Load all the tags from an external source, generated from tag.in.
-# include "tag_enum.h"
-  // Used for all tags that don't have special handling in HTML.  Add new tags
-  // to the end of tag.in so as to preserve backwards-compatibility.
+  // http://www.whatwg.org/specs/web-apps/current-work/multipage/semantics.html#the-root-element
+  GUMBO_TAG_HTML,
+  // http://www.whatwg.org/specs/web-apps/current-work/multipage/semantics.html#document-metadata
+  GUMBO_TAG_HEAD,
+  GUMBO_TAG_TITLE,
+  GUMBO_TAG_BASE,
+  GUMBO_TAG_LINK,
+  GUMBO_TAG_META,
+  GUMBO_TAG_STYLE,
+  // http://www.whatwg.org/specs/web-apps/current-work/multipage/scripting-1.html#scripting-1
+  GUMBO_TAG_SCRIPT,
+  GUMBO_TAG_NOSCRIPT,
+  GUMBO_TAG_TEMPLATE,
+  // http://www.whatwg.org/specs/web-apps/current-work/multipage/sections.html#sections
+  GUMBO_TAG_BODY,
+  GUMBO_TAG_ARTICLE,
+  GUMBO_TAG_SECTION,
+  GUMBO_TAG_NAV,
+  GUMBO_TAG_ASIDE,
+  GUMBO_TAG_H1,
+  GUMBO_TAG_H2,
+  GUMBO_TAG_H3,
+  GUMBO_TAG_H4,
+  GUMBO_TAG_H5,
+  GUMBO_TAG_H6,
+  GUMBO_TAG_HGROUP,
+  GUMBO_TAG_HEADER,
+  GUMBO_TAG_FOOTER,
+  GUMBO_TAG_ADDRESS,
+  // http://www.whatwg.org/specs/web-apps/current-work/multipage/grouping-content.html#grouping-content
+  GUMBO_TAG_P,
+  GUMBO_TAG_HR,
+  GUMBO_TAG_PRE,
+  GUMBO_TAG_BLOCKQUOTE,
+  GUMBO_TAG_OL,
+  GUMBO_TAG_UL,
+  GUMBO_TAG_LI,
+  GUMBO_TAG_DL,
+  GUMBO_TAG_DT,
+  GUMBO_TAG_DD,
+  GUMBO_TAG_FIGURE,
+  GUMBO_TAG_FIGCAPTION,
+  GUMBO_TAG_MAIN,
+  GUMBO_TAG_DIV,
+  // http://www.whatwg.org/specs/web-apps/current-work/multipage/text-level-semantics.html#text-level-semantics
+  GUMBO_TAG_A,
+  GUMBO_TAG_EM,
+  GUMBO_TAG_STRONG,
+  GUMBO_TAG_SMALL,
+  GUMBO_TAG_S,
+  GUMBO_TAG_CITE,
+  GUMBO_TAG_Q,
+  GUMBO_TAG_DFN,
+  GUMBO_TAG_ABBR,
+  GUMBO_TAG_DATA,
+  GUMBO_TAG_TIME,
+  GUMBO_TAG_CODE,
+  GUMBO_TAG_VAR,
+  GUMBO_TAG_SAMP,
+  GUMBO_TAG_KBD,
+  GUMBO_TAG_SUB,
+  GUMBO_TAG_SUP,
+  GUMBO_TAG_I,
+  GUMBO_TAG_B,
+  GUMBO_TAG_U,
+  GUMBO_TAG_MARK,
+  GUMBO_TAG_RUBY,
+  GUMBO_TAG_RT,
+  GUMBO_TAG_RP,
+  GUMBO_TAG_BDI,
+  GUMBO_TAG_BDO,
+  GUMBO_TAG_SPAN,
+  GUMBO_TAG_BR,
+  GUMBO_TAG_WBR,
+  // http://www.whatwg.org/specs/web-apps/current-work/multipage/edits.html#edits
+  GUMBO_TAG_INS,
+  GUMBO_TAG_DEL,
+  // http://www.whatwg.org/specs/web-apps/current-work/multipage/embedded-content-1.html#embedded-content-1
+  GUMBO_TAG_IMAGE,
+  GUMBO_TAG_IMG,
+  GUMBO_TAG_IFRAME,
+  GUMBO_TAG_EMBED,
+  GUMBO_TAG_OBJECT,
+  GUMBO_TAG_PARAM,
+  GUMBO_TAG_VIDEO,
+  GUMBO_TAG_AUDIO,
+  GUMBO_TAG_SOURCE,
+  GUMBO_TAG_TRACK,
+  GUMBO_TAG_CANVAS,
+  GUMBO_TAG_MAP,
+  GUMBO_TAG_AREA,
+  // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-map-element.html#mathml
+  GUMBO_TAG_MATH,
+  GUMBO_TAG_MI,
+  GUMBO_TAG_MO,
+  GUMBO_TAG_MN,
+  GUMBO_TAG_MS,
+  GUMBO_TAG_MTEXT,
+  GUMBO_TAG_MGLYPH,
+  GUMBO_TAG_MALIGNMARK,
+  GUMBO_TAG_ANNOTATION_XML,
+  // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-map-element.html#svg-0
+  GUMBO_TAG_SVG,
+  GUMBO_TAG_FOREIGNOBJECT,
+  GUMBO_TAG_DESC,
+  // SVG title tags will have GUMBO_TAG_TITLE as with HTML.
+  // http://www.whatwg.org/specs/web-apps/current-work/multipage/tabular-data.html#tabular-data
+  GUMBO_TAG_TABLE,
+  GUMBO_TAG_CAPTION,
+  GUMBO_TAG_COLGROUP,
+  GUMBO_TAG_COL,
+  GUMBO_TAG_TBODY,
+  GUMBO_TAG_THEAD,
+  GUMBO_TAG_TFOOT,
+  GUMBO_TAG_TR,
+  GUMBO_TAG_TD,
+  GUMBO_TAG_TH,
+  // http://www.whatwg.org/specs/web-apps/current-work/multipage/forms.html#forms
+  GUMBO_TAG_FORM,
+  GUMBO_TAG_FIELDSET,
+  GUMBO_TAG_LEGEND,
+  GUMBO_TAG_LABEL,
+  GUMBO_TAG_INPUT,
+  GUMBO_TAG_BUTTON,
+  GUMBO_TAG_SELECT,
+  GUMBO_TAG_DATALIST,
+  GUMBO_TAG_OPTGROUP,
+  GUMBO_TAG_OPTION,
+  GUMBO_TAG_TEXTAREA,
+  GUMBO_TAG_KEYGEN,
+  GUMBO_TAG_OUTPUT,
+  GUMBO_TAG_PROGRESS,
+  GUMBO_TAG_METER,
+  // http://www.whatwg.org/specs/web-apps/current-work/multipage/interactive-elements.html#interactive-elements
+  GUMBO_TAG_DETAILS,
+  GUMBO_TAG_SUMMARY,
+  GUMBO_TAG_MENU,
+  GUMBO_TAG_MENUITEM,
+  // Non-conforming elements that nonetheless appear in the HTML5 spec.
+  // http://www.whatwg.org/specs/web-apps/current-work/multipage/obsolete.html#non-conforming-features
+  GUMBO_TAG_APPLET,
+  GUMBO_TAG_ACRONYM,
+  GUMBO_TAG_BGSOUND,
+  GUMBO_TAG_DIR,
+  GUMBO_TAG_FRAME,
+  GUMBO_TAG_FRAMESET,
+  GUMBO_TAG_NOFRAMES,
+  GUMBO_TAG_ISINDEX,
+  GUMBO_TAG_LISTING,
+  GUMBO_TAG_XMP,
+  GUMBO_TAG_NEXTID,
+  GUMBO_TAG_NOEMBED,
+  GUMBO_TAG_PLAINTEXT,
+  GUMBO_TAG_RB,
+  GUMBO_TAG_STRIKE,
+  GUMBO_TAG_BASEFONT,
+  GUMBO_TAG_BIG,
+  GUMBO_TAG_BLINK,
+  GUMBO_TAG_CENTER,
+  GUMBO_TAG_FONT,
+  GUMBO_TAG_MARQUEE,
+  GUMBO_TAG_MULTICOL,
+  GUMBO_TAG_NOBR,
+  GUMBO_TAG_SPACER,
+  GUMBO_TAG_TT,
+  // Used for all tags that don't have special handling in HTML.
   GUMBO_TAG_UNKNOWN,
   // A marker value to indicate the end of the enum, for iterating over it.
   // Also used as the terminator for varargs functions that take tags.
@@ -202,10 +364,9 @@ const char* gumbo_normalize_svg_tagname(const GumboStringPiece* tagname);
 
 /**
  * Converts a tag name string (which may be in upper or mixed case) to a tag
- * enum. The `tag` version expects `tagname` to be NULL-terminated
+ * enum.
  */
 GumboTag gumbo_tag_enum(const char* tagname);
-GumboTag gumbo_tagn_enum(const char* tagname, unsigned int length);
 
 /**
  * Attribute namespaces.
@@ -300,16 +461,10 @@ typedef enum {
   GUMBO_NODE_TEXT,
   /** CDATA node. v will be a GumboText. */
   GUMBO_NODE_CDATA,
-  /** Comment node.  v will be a GumboText, excluding comment delimiters. */
+  /** Comment node.  v. will be a GumboText, excluding comment delimiters. */
   GUMBO_NODE_COMMENT,
   /** Text node, where all contents is whitespace.  v will be a GumboText. */
-  GUMBO_NODE_WHITESPACE,
-  /** Template node.  This is separate from GUMBO_NODE_ELEMENT because many
-   * client libraries will want to ignore the contents of template nodes, as
-   * the spec suggests.  Recursing on GUMBO_NODE_ELEMENT will do the right thing
-   * here, while clients that want to include template contents should also
-   * check for GUMBO_NODE_TEMPLATE.  v will be a GumboElement.  */
-  GUMBO_NODE_TEMPLATE
+  GUMBO_NODE_WHITESPACE
 } GumboNodeType;
 
 /**
@@ -523,19 +678,6 @@ struct GumboInternalNode {
   /** Pointer back to parent node.  Not owned. */
   GumboNode* parent;
 
-  /**
-   * Pointer to next node in document order.  This is the next node by start tag
-   * position in the document, or by position of the tag that forces the parser
-   * to insert it for parser-inserted nodes.  It's necessary to maintain API
-   * compatibility with some other libraries, eg. BeautifulSoup.  Not owned.
-   */
-  GumboNode* next;
-
-  /**
-   * Pointer to previous node in document order.
-   */
-  GumboNode* prev;
-
   /** The index within the parent's children vector of this node. */
   size_t index_within_parent;
 
@@ -653,14 +795,6 @@ GumboOutput* gumbo_parse(const char* buffer);
 GumboOutput* gumbo_parse_with_options(
     const GumboOptions* options, const char* buffer, size_t buffer_length);
 
-/**
- * Parse a chunk of HTML with the given fragment context. If `fragment_ctx`
- * is `GUMBO_TAG_LAST`, the fragment will be parsed as a full document.
- */
-GumboOutput* gumbo_parse_fragment(
-    const GumboOptions* options, const char* buffer, size_t length,
-    const GumboTag fragment_ctx, const GumboNamespaceEnum fragment_namespace);
-
 /** Release the memory used for the parse tree & parse errors. */
 void gumbo_destroy_output(
     const GumboOptions* options, GumboOutput* output);

data/gumbo-parser/src/parser.c

@@ -47,15 +47,6 @@ typedef char gumbo_tagset[GUMBO_TAG_LAST];
    tagset[(int)tag] == (1 << (int)namespace))
 
 
-
-// selected forward declarations as it is getting hard to find
-// an appropriate order
-static bool node_html_tag_is(const GumboNode*, GumboTag);
-static GumboInsertionMode get_current_template_insertion_mode(const GumboParser*);
-static bool handle_in_template(GumboParser*, GumboToken*);
-static GumboNode* destroy_node(GumboParser*, GumboNode*);
-
-
 static void* malloc_wrapper(void* unused, size_t size) {
   return malloc(size);
 }
@@ -199,7 +190,7 @@ typedef struct _ReplacementEntry {
     { GUMBO_STRING(from), GUMBO_STRING(to) }
 
 // Static data for SVG attribute replacements.
-// https://html.spec.whatwg.org/multipage/syntax.html#creating-and-inserting-nodes
+// http://www.whatwg.org/specs/web-apps/current-work/multipage/tree-construction.html#adjust-svg-attributes
 static const ReplacementEntry kSvgAttributeReplacements[] = {
   REPLACEMENT_ENTRY("attributename", "attributeName"),
   REPLACEMENT_ENTRY("attributetype", "attributeType"),
@@ -207,12 +198,12 @@ static const ReplacementEntry kSvgAttributeReplacements[] = {
   REPLACEMENT_ENTRY("baseprofile", "baseProfile"),
   REPLACEMENT_ENTRY("calcmode", "calcMode"),
   REPLACEMENT_ENTRY("clippathunits", "clipPathUnits"),
-  // REPLACEMENT_ENTRY("contentscripttype", "contentScriptType"),
-  // REPLACEMENT_ENTRY("contentstyletype", "contentStyleType"),
+  REPLACEMENT_ENTRY("contentscripttype", "contentScriptType"),
+  REPLACEMENT_ENTRY("contentstyletype", "contentStyleType"),
   REPLACEMENT_ENTRY("diffuseconstant", "diffuseConstant"),
   REPLACEMENT_ENTRY("edgemode", "edgeMode"),
-  // REPLACEMENT_ENTRY("externalresourcesrequired", "externalResourcesRequired"),
-  // REPLACEMENT_ENTRY("filterres", "filterRes"),
+  REPLACEMENT_ENTRY("externalresourcesrequired", "externalResourcesRequired"),
+  REPLACEMENT_ENTRY("filterres", "filterRes"),
   REPLACEMENT_ENTRY("filterunits", "filterUnits"),
   REPLACEMENT_ENTRY("glyphref", "glyphRef"),
   REPLACEMENT_ENTRY("gradienttransform", "gradientTransform"),
@@ -380,9 +371,6 @@ typedef struct GumboInternalParserState {
   GumboNode* _head_element;
   GumboNode* _form_element;
 
-  // The element used as fragment context when parsing in fragment mode
-  GumboNode* _fragment_ctx;
-
   // The flag for when the spec says "Reprocess the current token in..."
   bool _reprocess_current_token;
 
@@ -411,10 +399,6 @@ typedef struct GumboInternalParserState {
   // The current token.
   GumboToken* _current_token;
 
-  // The current (most recently inserted) node.  This is used to link together
-  // nodes in document order.
-  GumboNode* _current_node;
-
   // The way that the spec is written, the </body> and </html> tags are *always*
   // implicit, because encountering one of those tokens merely switches the
   // insertion mode out of "in body".  So we have individual state flags for
@@ -467,17 +451,7 @@ static void set_frameset_not_ok(GumboParser* parser) {
 }
 
 static GumboNode* create_node(GumboParser* parser, GumboNodeType type) {
-  GumboParserState* state = parser->_parser_state;
   GumboNode* node = gumbo_parser_allocate(parser, sizeof(GumboNode));
-
-  node->next = NULL;
-  node->prev = state->_current_node;
-  if (state->_current_node != NULL) {
-    // May be null for the initial document node.
-    state->_current_node->next = node;
-  }
-  state->_current_node = node;
-
   node->parent = NULL;
   node->index_within_parent = -1;
   node->type = type;
@@ -524,9 +498,7 @@ static void parser_state_init(GumboParser* parser) {
   gumbo_vector_init(parser, 5, &parser_state->_template_insertion_modes);
   parser_state->_head_element = NULL;
   parser_state->_form_element = NULL;
-  parser_state->_fragment_ctx = NULL;
   parser_state->_current_token = NULL;
-  parser_state->_current_node = NULL;
   parser_state->_closed_body_tag = false;
   parser_state->_closed_html_tag = false;
   parser->_parser_state = parser_state;
@@ -534,25 +506,17 @@ static void parser_state_init(GumboParser* parser) {
 
 static void parser_state_destroy(GumboParser* parser) {
   GumboParserState* state = parser->_parser_state;
-  if (state->_fragment_ctx) {
-    destroy_node(parser, state->_fragment_ctx);
-  }
   gumbo_vector_destroy(parser, &state->_active_formatting_elements);
   gumbo_vector_destroy(parser, &state->_open_elements);
   gumbo_vector_destroy(parser, &state->_template_insertion_modes);
   gumbo_string_buffer_destroy(parser, &state->_text_node._buffer);
   gumbo_parser_deallocate(parser, state);
-  parser->_parser_state = NULL;
 }
 
 static GumboNode* get_document_node(GumboParser* parser) {
   return parser->_output->document;
 }
 
-static bool is_fragment_parser(const GumboParser *parser) {
-  return !!parser->_parser_state->_fragment_ctx;
-}
-
 // Returns the node at the bottom of the stack of open elements, or NULL if no
 // elements have been added yet.
 static GumboNode* get_current_node(GumboParser* parser) {
@@ -566,14 +530,6 @@ static GumboNode* get_current_node(GumboParser* parser) {
   return open_elements->data[open_elements->length - 1];
 }
 
-static GumboNode* get_adjusted_current_node(GumboParser* parser) {
-  GumboParserState *state = parser->_parser_state;
-  if (state->_open_elements.length == 1 && state->_fragment_ctx) {
-    return state->_fragment_ctx;
-  }
-  return get_current_node(parser);
-}
-
 // Returns true if the given needle is in the given array of literal
 // GumboStringPieces.  If exact_match is true, this requires that they match
 // exactly; otherwise, this performs a prefix match to check if any of the
@@ -594,80 +550,55 @@ static void set_insertion_mode(GumboParser* parser, GumboInsertionMode mode) {
   parser->_parser_state->_insertion_mode = mode;
 }
 
-
 // http://www.whatwg.org/specs/web-apps/current-work/complete/parsing.html#reset-the-insertion-mode-appropriately
 // This is a helper function that returns the appropriate insertion mode instead
 // of setting it.  Returns GUMBO_INSERTION_MODE_INITIAL as a sentinel value to
 // indicate that there is no appropriate insertion mode, and the loop should
 // continue.
-static GumboInsertionMode get_appropriate_insertion_mode(const GumboParser* parser, int index) {
-  const GumboVector* open_elements = &parser->_parser_state->_open_elements;
-  const GumboNode* node = open_elements->data[index];
-  const bool is_last = index == 0;
-
-  if (is_last && is_fragment_parser(parser)) {
-    node = parser->_parser_state->_fragment_ctx;
-  }
+static GumboInsertionMode get_appropriate_insertion_mode(
+    const GumboNode* node, bool is_last) {
+  assert(node->type == GUMBO_NODE_ELEMENT);
 
-  assert(node->type == GUMBO_NODE_ELEMENT || node->type == GUMBO_NODE_TEMPLATE);
-  switch (node->v.element.tag) {
-  case GUMBO_TAG_SELECT: {
-    if (is_last) {
-      return GUMBO_INSERTION_MODE_IN_SELECT;
-    }
-    for (int i = index; i > 0; --i) {
-      const GumboNode* ancestor = open_elements->data[i];
-      if (node_html_tag_is(ancestor, GUMBO_TAG_TEMPLATE)) {
-        return GUMBO_INSERTION_MODE_IN_SELECT;
-      }
-      if (node_html_tag_is(ancestor, GUMBO_TAG_TABLE)) {
-        return GUMBO_INSERTION_MODE_IN_SELECT_IN_TABLE;
-      }
-    }
-    return GUMBO_INSERTION_MODE_IN_SELECT;
-  }
-  case GUMBO_TAG_TD:
-  case GUMBO_TAG_TH:
-      if (!is_last) return GUMBO_INSERTION_MODE_IN_CELL;
-      break;
-  case GUMBO_TAG_TR:
-    return GUMBO_INSERTION_MODE_IN_ROW;
-  case GUMBO_TAG_TBODY:
-  case GUMBO_TAG_THEAD:
-  case GUMBO_TAG_TFOOT:
-    return GUMBO_INSERTION_MODE_IN_TABLE_BODY;
-  case GUMBO_TAG_CAPTION:
-    return GUMBO_INSERTION_MODE_IN_CAPTION;
-  case GUMBO_TAG_COLGROUP:
-    return GUMBO_INSERTION_MODE_IN_COLUMN_GROUP;
-  case GUMBO_TAG_TABLE:
-    return GUMBO_INSERTION_MODE_IN_TABLE;
-  case GUMBO_TAG_TEMPLATE:
-    return get_current_template_insertion_mode(parser);
-  case GUMBO_TAG_HEAD:
-      if (!is_last) return GUMBO_INSERTION_MODE_IN_HEAD;
-      break;
-  case GUMBO_TAG_BODY:
-    return GUMBO_INSERTION_MODE_IN_BODY;
-  case GUMBO_TAG_FRAMESET:
-    return GUMBO_INSERTION_MODE_IN_FRAMESET;
-  case GUMBO_TAG_HTML:
-      return parser->_parser_state->_head_element ?
-        GUMBO_INSERTION_MODE_AFTER_HEAD : GUMBO_INSERTION_MODE_BEFORE_HEAD;
-  default:
-      break;
-  }
-  return is_last ?
-    GUMBO_INSERTION_MODE_IN_BODY : GUMBO_INSERTION_MODE_INITIAL;
+  if (node->v.element.tag_namespace == GUMBO_NAMESPACE_HTML) {
+    switch (node->v.element.tag) {
+        case GUMBO_TAG_SELECT:
+          return GUMBO_INSERTION_MODE_IN_SELECT;
+        case GUMBO_TAG_TD:
+        case GUMBO_TAG_TH:
+          return is_last ?
+                  GUMBO_INSERTION_MODE_IN_BODY : GUMBO_INSERTION_MODE_IN_CELL;
+        case GUMBO_TAG_TR:
+            return GUMBO_INSERTION_MODE_IN_ROW;
+        case GUMBO_TAG_TBODY:
+        case GUMBO_TAG_THEAD:
+        case GUMBO_TAG_TFOOT:
+          return GUMBO_INSERTION_MODE_IN_TABLE_BODY;
+        case GUMBO_TAG_CAPTION:
+          return GUMBO_INSERTION_MODE_IN_CAPTION;
+        case GUMBO_TAG_COLGROUP:
+          return GUMBO_INSERTION_MODE_IN_COLUMN_GROUP;
+        case GUMBO_TAG_TABLE:
+          return GUMBO_INSERTION_MODE_IN_TABLE;
+        case GUMBO_TAG_HEAD:
+        case GUMBO_TAG_BODY:
+          return GUMBO_INSERTION_MODE_IN_BODY;
+        case GUMBO_TAG_FRAMESET:
+          return GUMBO_INSERTION_MODE_IN_FRAMESET;
+        case GUMBO_TAG_HTML:
+          return GUMBO_INSERTION_MODE_BEFORE_HEAD;
+        default:
+          break;
+    }
+  }
+  return is_last ? GUMBO_INSERTION_MODE_IN_BODY : GUMBO_INSERTION_MODE_INITIAL;
 }
 
-
 // This performs the actual "reset the insertion mode" loop.
 static void reset_insertion_mode_appropriately(GumboParser* parser) {
   const GumboVector* open_elements = &parser->_parser_state->_open_elements;
   for (int i = open_elements->length; --i >= 0; ) {
     GumboInsertionMode mode =
-        get_appropriate_insertion_mode(parser, i);
+        get_appropriate_insertion_mode(open_elements->data[i], i == 0);
     if (mode != GUMBO_INSERTION_MODE_INITIAL) {
       set_insertion_mode(parser, mode);
       return;
@@ -701,7 +632,7 @@ static GumboError* parser_add_parse_error(GumboParser* parser, const GumboToken*
                    &extra_data->tag_stack);
   for (int i = 0; i < state->_open_elements.length; ++i) {
     const GumboNode* node = state->_open_elements.data[i];
-    assert(node->type == GUMBO_NODE_ELEMENT || node->type == GUMBO_NODE_TEMPLATE);
+    assert(node->type == GUMBO_NODE_ELEMENT);
     gumbo_vector_add(parser, (void*) node->v.element.tag,
                     &extra_data->tag_stack);
   }
@@ -738,7 +669,7 @@ static bool tag_is(const GumboToken* token, bool is_start, GumboTag tag) {
 // Like tag_in, but checks for the tag of a node, rather than a token.
 static bool node_tag_in_set(const GumboNode* node, const gumbo_tagset tags) {
   assert(node != NULL);
-  if (node->type != GUMBO_NODE_ELEMENT && node->type != GUMBO_NODE_TEMPLATE) {
+  if (node->type != GUMBO_NODE_ELEMENT) {
     return false;
   }
   return TAGSET_INCLUDES(tags, node->v.element.tag_namespace, node->v.element.tag);
@@ -747,7 +678,7 @@ static bool node_tag_in_set(const GumboNode* node, const gumbo_tagset tags) {
 
 // Like node_tag_in, but for the single-tag case.
 static bool node_qualified_tag_is(const GumboNode* node, GumboNamespaceEnum ns, GumboTag tag) {
-  return (node->type == GUMBO_NODE_ELEMENT || node->type == GUMBO_NODE_TEMPLATE) &&
+  return node->type == GUMBO_NODE_ELEMENT &&
     node->v.element.tag == tag &&
     node->v.element.tag_namespace == ns;
 }
@@ -758,23 +689,6 @@ static bool node_html_tag_is(const GumboNode* node, GumboTag tag)
   return node_qualified_tag_is(node, GUMBO_NAMESPACE_HTML, tag);
 }
 
-static void push_template_insertion_mode(GumboParser* parser, GumboInsertionMode mode) {
-  gumbo_vector_add(parser, (void*) mode, &parser->_parser_state->_template_insertion_modes);
-}
-
-static void pop_template_insertion_mode(GumboParser* parser) {
-  gumbo_vector_pop(parser, &parser->_parser_state->_template_insertion_modes);
-}
-
-// Returns the current template insertion mode.  If the stack of template
-// insertion modes is empty, this returns GUMBO_INSERTION_MODE_INITIAL.
-static GumboInsertionMode get_current_template_insertion_mode(const GumboParser* parser) {
-  GumboVector* template_insertion_modes = &parser->_parser_state->_template_insertion_modes;
-  if (template_insertion_modes->length == 0) {
-    return GUMBO_INSERTION_MODE_INITIAL;
-  }
-  return (GumboInsertionMode) template_insertion_modes->data[(template_insertion_modes->length - 1)];
-}
 
 // http://www.whatwg.org/specs/web-apps/current-work/multipage/tree-construction.html#mathml-text-integration-point
 static bool is_mathml_integration_point(const GumboNode* node) {
@@ -792,63 +706,6 @@ static bool is_html_integration_point(const GumboNode* node) {
                             "encoding", "application/xhtml+xml")));
 }
 
-
-// This represents a place to insert a node, consisting of a target parent and a
-// child index within that parent.  If the node should be inserted at the end of
-// the parent's child, index will be -1.
-typedef struct {
-  GumboNode* target;
-  int index;
-} InsertionLocation;
-
-InsertionLocation get_appropriate_insertion_location(GumboParser* parser, GumboNode* override_target) {
-  InsertionLocation retval = { override_target, -1 };
-  if (retval.target == NULL) {
-    // No override target; default to the current node, but special-case the
-    // root node since get_current_node() assumes the stack of open elements is
-    // non-empty.
-    retval.target = parser->_output->root != NULL ?
-      get_current_node(parser) : get_document_node(parser);
-  }
-  if (!parser->_parser_state->_foster_parent_insertions ||
-      !node_tag_in_set(retval.target, (gumbo_tagset) { TAG(TABLE), TAG(TBODY),
-                           TAG(TFOOT), TAG(THEAD), TAG(TR) })) {
-    return retval;
-  }
-
-  // Foster-parenting case.
-  int last_template_index = -1;
-  int last_table_index = -1;
-  GumboVector* open_elements = &parser->_parser_state->_open_elements;
-  for (int i = 0; i < open_elements->length; ++i) {
-    if (node_html_tag_is(open_elements->data[i], GUMBO_TAG_TEMPLATE)) {
-      last_template_index = i;
-    }
-    if (node_html_tag_is(open_elements->data[i], GUMBO_TAG_TABLE)) {
-      last_table_index = i;
-    }
-  }
-  if (last_template_index != -1 &&
-      (last_table_index == -1 || last_template_index > last_table_index)) {
-    retval.target = open_elements->data[last_template_index];
-    return retval;
-  }
-  if (last_table_index == -1) {
-    retval.target = open_elements->data[0];
-    return retval;
-  }
-  GumboNode* last_table = open_elements->data[last_table_index];
-  if (last_table->parent != NULL) {
-    retval.target = last_table->parent;
-    retval.index = last_table->index_within_parent;
-    return retval;
-  }
-
-  retval.target = open_elements->data[last_table_index - 1];
-  return retval;
-}
-
-
 // Appends a node to the end of its parent, setting the "parent" and
 // "index_within_parent" fields appropriately.
 static void append_node(
@@ -856,7 +713,7 @@ static void append_node(
   assert(node->parent == NULL);
   assert(node->index_within_parent == -1);
   GumboVector* children;
-  if (parent->type == GUMBO_NODE_ELEMENT || parent->type == GUMBO_NODE_TEMPLATE) {
+  if (parent->type == GUMBO_NODE_ELEMENT) {
     children = &parent->v.element.children;
   } else {
     assert(parent->type == GUMBO_NODE_DOCUMENT);
@@ -868,44 +725,66 @@ static void append_node(
   assert(node->index_within_parent < children->length);
 }
 
-// Inserts a node at the specified InsertionLocation, updating the
+// Inserts a node at the specified index within its parent, updating the
 // "parent" and "index_within_parent" fields of it and all its siblings.
-// If the index of the location is -1, this calls append_node.
 static void insert_node(
-                        GumboParser* parser, GumboNode* node, InsertionLocation location) {
+    GumboParser* parser, GumboNode* parent, int index, GumboNode* node) {
   assert(node->parent == NULL);
   assert(node->index_within_parent == -1);
-  GumboNode* parent = location.target;
-  int index = location.index;
-  if (index != -1) {
-    GumboVector* children = NULL;
-    if (parent->type == GUMBO_NODE_ELEMENT ||
-        parent->type == GUMBO_NODE_TEMPLATE) {
-      children = &parent->v.element.children;
-    } else if (parent->type == GUMBO_NODE_DOCUMENT) {
-      children = &parent->v.document.children;
-      assert(children->length == 0);
-    } else {
-      assert(0);
-    }
+  assert(parent->type == GUMBO_NODE_ELEMENT);
+  GumboVector* children = &parent->v.element.children;
+  assert(index >= 0);
+  assert(index < children->length);
+  node->parent = parent;
+  node->index_within_parent = index;
+  gumbo_vector_insert_at(parser, (void*) node, index, children);
+  assert(node->index_within_parent < children->length);
+  for (int i = index + 1; i < children->length; ++i) {
+    GumboNode* sibling = children->data[i];
+    sibling->index_within_parent = i;
+    assert(sibling->index_within_parent < children->length);
+  }
+}
 
-    assert(index >= 0);
-    assert(index < children->length);
-    node->parent = parent;
-    node->index_within_parent = index;
-    gumbo_vector_insert_at(parser, (void*) node, index, children);
-    assert(node->index_within_parent < children->length);
-    for (int i = index + 1; i < children->length; ++i) {
-      GumboNode* sibling = children->data[i];
-      sibling->index_within_parent = i;
-      assert(sibling->index_within_parent < children->length);
+// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#foster-parenting
+static void foster_parent_element(GumboParser* parser, GumboNode* node) {
+  GumboVector* open_elements = &parser->_parser_state->_open_elements;
+  assert(open_elements->length > 2);
+
+  node->parse_flags |= GUMBO_INSERTION_FOSTER_PARENTED;
+  GumboNode* foster_parent_element = open_elements->data[0];
+  assert(foster_parent_element->type == GUMBO_NODE_ELEMENT);
+  assert(node_html_tag_is(foster_parent_element, GUMBO_TAG_HTML));
+  for (int i = open_elements->length; --i > 1; ) {
+    GumboNode* table_element = open_elements->data[i];
+    if (node_html_tag_is(table_element, GUMBO_TAG_TABLE)) {
+      foster_parent_element = table_element->parent;
+      if (!foster_parent_element ||
+          foster_parent_element->type != GUMBO_NODE_ELEMENT) {
+        // Table has no parent; spec says it's possible if a script manipulated
+        // the DOM, although I don't think we have to worry about this case.
+        gumbo_debug("Table has no parent.\n");
+        foster_parent_element = open_elements->data[i - 1];
+        break;
+      }
+      assert(foster_parent_element->type == GUMBO_NODE_ELEMENT);
+      gumbo_debug("Found enclosing table (%x) at %d; parent=%s, index=%d.\n",
+                 table_element, i, gumbo_normalized_tagname(
+                     foster_parent_element->v.element.tag),
+                 table_element->index_within_parent);
+      assert(foster_parent_element->v.element.children.data[
+             table_element->index_within_parent] == table_element);
+      insert_node(parser, foster_parent_element,
+                  table_element->index_within_parent, node);
+      return;
     }
-  } else {
-    append_node(parser, parent, node);
   }
+  if (node->type == GUMBO_NODE_ELEMENT) {
+    gumbo_vector_add(parser, (void*) node, open_elements);
+  }
+  append_node(parser, foster_parent_element, node);
 }
 
-
 static void maybe_flush_text_node_buffer(GumboParser* parser) {
   GumboParserState* state = parser->_parser_state;
   TextNodeBufferState* buffer_state = &state->_text_node;
@@ -925,20 +804,20 @@ static void maybe_flush_text_node_buffer(GumboParser* parser) {
       state->_current_token->original_text.data -
       buffer_state->_start_original_text;
   text_node_data->start_pos = buffer_state->_start_position;
-
-  gumbo_debug("Flushing text node buffer of %.*s.\n",
-             (int) buffer_state->_buffer.length, buffer_state->_buffer.data);
-
-  InsertionLocation location = get_appropriate_insertion_location(parser, NULL);
-  if (location.target->type == GUMBO_NODE_DOCUMENT) {
-    // The DOM does not allow Document nodes to have Text children, so per the
-    // spec, they are dropped on the floor.
-    destroy_node(parser, text_node);
+  if (state->_foster_parent_insertions && 
+      node_tag_in_set(get_current_node(parser), (gumbo_tagset) { TAG(TABLE), TAG(TBODY), TAG(TFOOT),
+            TAG(THEAD), TAG(TR) })) {
+    foster_parent_element(parser, text_node);
   } else {
-    insert_node(parser, text_node, location);
+    append_node(
+        parser, parser->_output->root ?
+        get_current_node(parser) : parser->_output->document, text_node);
   }
+  gumbo_debug("Flushing text node buffer of %.*s.\n",
+             (int) buffer_state->_buffer.length, buffer_state->_buffer.data);
 
-  gumbo_string_buffer_clear(parser, &buffer_state->_buffer);
+  gumbo_string_buffer_destroy(parser, &buffer_state->_buffer);
+  gumbo_string_buffer_init(parser, &buffer_state->_buffer);
   buffer_state->_type = GUMBO_NODE_WHITESPACE;
   assert(buffer_state->_buffer.length == 0);
 }
@@ -965,7 +844,7 @@ static GumboNode* pop_current_node(GumboParser* parser) {
     assert(state->_open_elements.length == 0);
     return NULL;
   }
-  assert(current_node->type == GUMBO_NODE_ELEMENT || current_node->type == GUMBO_NODE_TEMPLATE);
+  assert(current_node->type == GUMBO_NODE_ELEMENT);
   bool is_closed_body_or_html_tag =
       (node_html_tag_is(current_node, GUMBO_TAG_BODY) && state->_closed_body_tag) ||
       (node_html_tag_is(current_node, GUMBO_TAG_HTML) && state->_closed_html_tag);
@@ -994,14 +873,14 @@ static void append_comment_node(
 
 // http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#clear-the-stack-back-to-a-table-row-context
 static void clear_stack_to_table_row_context(GumboParser* parser) {
-  while (!node_tag_in_set(get_current_node(parser), (gumbo_tagset) { TAG(HTML), TAG(TR), TAG(TEMPLATE)})) {
+  while (!node_tag_in_set(get_current_node(parser), (gumbo_tagset) { TAG(HTML), TAG(TR) })) {
     pop_current_node(parser);
   }
 }
 
 // http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#clear-the-stack-back-to-a-table-context
 static void clear_stack_to_table_context(GumboParser* parser) {
-  while (!node_tag_in_set(get_current_node(parser), (gumbo_tagset) { TAG(HTML), TAG(TABLE), TAG(TEMPLATE) } )) {
+  while (!node_tag_in_set(get_current_node(parser), (gumbo_tagset) { TAG(HTML), TAG(TABLE) } )) {
     pop_current_node(parser);
   }
 }
@@ -1009,7 +888,7 @@ static void clear_stack_to_table_context(GumboParser* parser) {
 // http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#clear-the-stack-back-to-a-table-body-context
 void clear_stack_to_table_body_context(GumboParser* parser) {
   while (!node_tag_in_set(get_current_node(parser), (gumbo_tagset) { TAG(HTML), TAG(TBODY),
-          TAG(TFOOT), TAG(THEAD), TAG(TEMPLATE) })) {
+          TAG(TFOOT), TAG(THEAD) })) {
     pop_current_node(parser);
   }
 }
@@ -1024,8 +903,7 @@ static GumboNode* create_element(GumboParser* parser, GumboTag tag) {
   element->tag_namespace = GUMBO_NAMESPACE_HTML;
   element->original_tag = kGumboEmptyString;
   element->original_end_tag = kGumboEmptyString;
-  element->start_pos = (parser->_parser_state->_current_token) ?
-    parser->_parser_state->_current_token->position : kGumboEmptySourcePosition;
+  element->start_pos = parser->_parser_state->_current_token->position;
   element->end_pos = kGumboEmptySourcePosition;
   return node;
 }
@@ -1036,12 +914,7 @@ static GumboNode* create_element_from_token(
   assert(token->type == GUMBO_TOKEN_START_TAG);
   GumboTokenStartTag* start_tag = &token->v.start_tag;
 
-  GumboNodeType type = (
-      tag_namespace == GUMBO_NAMESPACE_HTML &&
-      start_tag->tag == GUMBO_TAG_TEMPLATE)
-        ? GUMBO_NODE_TEMPLATE : GUMBO_NODE_ELEMENT;
-
-  GumboNode* node = create_node(parser, type);
+  GumboNode* node = create_node(parser, GUMBO_NODE_ELEMENT);
   GumboElement* element = &node->v.element;
   gumbo_vector_init(parser, 1, &element->children);
   element->attributes = start_tag->attributes;
@@ -1078,9 +951,20 @@ static void insert_element(GumboParser* parser, GumboNode* node,
   if (!is_reconstructing_formatting_elements) {
     maybe_flush_text_node_buffer(parser);
   }
-  InsertionLocation location =
-    get_appropriate_insertion_location(parser, NULL);
-  insert_node(parser, node, location);
+  if (state->_foster_parent_insertions && 
+      node_tag_in_set(get_current_node(parser), (gumbo_tagset) { TAG(TABLE), TAG(TBODY), TAG(TFOOT),
+            TAG(THEAD), TAG(TR) } )) {
+    foster_parent_element(parser, node);
+    gumbo_vector_add(parser, (void*) node, &state->_open_elements);
+    return;
+  }
+
+  // This is called to insert the root HTML element, but get_current_node
+  // assumes the stack of open elements is non-empty, so we need special
+  // handling for this case.
+  append_node(
+      parser, parser->_output->root ?
+      get_current_node(parser) : parser->_output->document, node);
   gumbo_vector_add(parser, (void*) node, &state->_open_elements);
 }
 
@@ -1253,7 +1137,7 @@ static bool is_open_element(GumboParser* parser, const GumboNode* node) {
 // values are fresh copies.
 GumboNode* clone_node(
     GumboParser* parser, const GumboNode* node, GumboParseFlags reason) {
-  assert(node->type == GUMBO_NODE_ELEMENT || node->type == GUMBO_NODE_TEMPLATE);
+  assert(node->type == GUMBO_NODE_ELEMENT);
   GumboNode* new_node = gumbo_parser_allocate(parser, sizeof(GumboNode));
   *new_node = *node;
   new_node->parent = NULL;
@@ -1323,10 +1207,7 @@ static void reconstruct_active_formatting_elements(GumboParser* parser) {
     GumboNode* clone = clone_node(
         parser, element, GUMBO_INSERTION_RECONSTRUCTED_FORMATTING_ELEMENT);
     // Step 9.
-    InsertionLocation location = get_appropriate_insertion_location(parser, NULL);
-    insert_node(parser, clone, location);
-    gumbo_vector_add(parser, (void*) clone, &parser->_parser_state->_open_elements);
-
+    insert_element(parser, clone, true);
     // Step 10.
     elements->data[i] = clone;
     gumbo_debug("Reconstructed %s element at %d.\n",
@@ -1380,40 +1261,37 @@ static GumboQuirksModeEnum compute_quirks_mode(
 // names.  For example, "has an element in list scope" looks for an element of
 // the given qualified name within the nearest enclosing <ol> or <ul>, along
 // with a bunch of generic element types that serve to "firewall" their content
-// from the rest of the document. Note that because of the way the spec is written,
-// all elements are expected to be in the HTML namespace
-static bool has_an_element_in_specific_scope(GumboParser* parser,
-    int expected_size, const GumboTag *expected, bool negate, const gumbo_tagset tags) {
+// from the rest of the document.
+static bool has_an_element_in_specific_scope(GumboParser* parser, gumbo_tagset expected, bool negate, const gumbo_tagset tags) {
   GumboVector* open_elements = &parser->_parser_state->_open_elements;
+  bool result = false;
   for (int i = open_elements->length; --i >= 0; ) {
     const GumboNode* node = open_elements->data[i];
-    if (node->type != GUMBO_NODE_ELEMENT && node->type != GUMBO_NODE_TEMPLATE)
+    if (node->type != GUMBO_NODE_ELEMENT) {
       continue;
-
-    GumboTag node_tag = node->v.element.tag;
-    GumboNamespaceEnum node_ns = node->v.element.tag_namespace;
-    for (int j = 0; j < expected_size; ++j) {
-      if (node_tag == expected[j] && node_ns == GUMBO_NAMESPACE_HTML)
-        return true;
     }
-
-    bool found = TAGSET_INCLUDES(tags, node_ns, node_tag);
-    if (negate != found)
-      return false;
+    if (TAGSET_INCLUDES(expected, node->v.element.tag_namespace, node->v.element.tag)) {
+      return true;
+    }
+    bool found_qualname = false;
+    if (TAGSET_INCLUDES(tags, node->v.element.tag_namespace, node->v.element.tag)) {
+      found_qualname = true;
+    }
+    if (negate != found_qualname) {
+      result = false;
+      return result;
+    }
   }
-  return false;
-}
-
-// Checks for the presence of an open element of the specified tag type.
-static bool has_open_element(GumboParser* parser, GumboTag tag) {
-  return has_an_element_in_specific_scope(parser, 1, &tag, false, (gumbo_tagset) { TAG(HTML) } );
+  return result;
 }
 
 // http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#has-an-element-in-scope
 static bool has_an_element_in_scope(GumboParser* parser, GumboTag tag) {
-  return has_an_element_in_specific_scope(parser, 1, &tag, false, (gumbo_tagset) { TAG(APPLET),
+  gumbo_tagset qualset = {0};
+  qualset[(int) tag] = (1 << (int) GUMBO_NAMESPACE_HTML);
+  return has_an_element_in_specific_scope(parser, qualset, false, (gumbo_tagset) { TAG(APPLET), 
         TAG(CAPTION), TAG(HTML), TAG(TABLE), TAG(TD), TAG(TH), TAG(MARQUEE),
-        TAG(OBJECT), TAG(TEMPLATE), TAG_MATHML(MI), TAG_MATHML(MO), TAG_MATHML(MN),
+        TAG(OBJECT), TAG_MATHML(MI), TAG_MATHML(MO), TAG_MATHML(MN),
         TAG_MATHML(MS), TAG_MATHML(MTEXT), TAG_MATHML(ANNOTATION_XML),
         TAG_SVG(FOREIGNOBJECT), TAG_SVG(DESC), TAG_SVG(TITLE) });
 }
@@ -1431,11 +1309,11 @@ static bool has_node_in_scope(GumboParser* parser, const GumboNode* node) {
     if (current == node) {
       return true;
     }
-    if (current->type != GUMBO_NODE_ELEMENT && current->type != GUMBO_NODE_TEMPLATE) {
+    if (current->type != GUMBO_NODE_ELEMENT) {
       continue;
     }
     if (node_tag_in_set(current, (gumbo_tagset) { TAG(APPLET), TAG(CAPTION), TAG(HTML), 
-            TAG(TABLE), TAG(TD), TAG(TH), TAG(MARQUEE), TAG(OBJECT), TAG(TEMPLATE),
+            TAG(TABLE), TAG(TD), TAG(TH), TAG(MARQUEE), TAG(OBJECT),
             TAG_MATHML(MI), TAG_MATHML(MO), TAG_MATHML(MN), TAG_MATHML(MS),
             TAG_MATHML(MTEXT), TAG_MATHML(ANNOTATION_XML), TAG_SVG(FOREIGNOBJECT),
             TAG_SVG(DESC), TAG_SVG(TITLE) } )) {
@@ -1448,19 +1326,21 @@ static bool has_node_in_scope(GumboParser* parser, const GumboNode* node) {
 
 // Like has_an_element_in_scope, but restricts the expected qualified name to a
 // range of possible qualified names instead of just a single one.
-static bool has_an_element_in_scope_with_tagname(GumboParser* parser, int expected_len, const GumboTag expected[]) {
-  return has_an_element_in_specific_scope(parser, expected_len, expected, false, (gumbo_tagset) {
-      TAG(APPLET), TAG(CAPTION), TAG(HTML), TAG(TABLE), TAG(TD), TAG(TH), TAG(MARQUEE),
-      TAG(OBJECT), TAG(TEMPLATE), TAG_MATHML(MI), TAG_MATHML(MO), TAG_MATHML(MN),
-      TAG_MATHML(MS), TAG_MATHML(MTEXT), TAG_MATHML(ANNOTATION_XML),
-      TAG_SVG(FOREIGNOBJECT), TAG_SVG(DESC), TAG_SVG(TITLE) });
+static bool has_an_element_in_scope_with_tagname(GumboParser* parser, gumbo_tagset qualset) {
+  return has_an_element_in_specific_scope(parser, qualset, false, (gumbo_tagset) { TAG(APPLET), 
+        TAG(CAPTION), TAG(HTML), TAG(TABLE), TAG(TD), TAG(TH), TAG(MARQUEE),
+        TAG(OBJECT), TAG_MATHML(MI), TAG_MATHML(MO), TAG_MATHML(MN),
+        TAG_MATHML(MS), TAG_MATHML(MTEXT), TAG_MATHML(ANNOTATION_XML),
+        TAG_SVG(FOREIGNOBJECT), TAG_SVG(DESC), TAG_SVG(TITLE) });
 }
 
 // http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#has-an-element-in-list-item-scope
 static bool has_an_element_in_list_scope(GumboParser* parser, GumboTag tag) {
-  return has_an_element_in_specific_scope(parser, 1, &tag, false, (gumbo_tagset) { TAG(APPLET),
+  gumbo_tagset qualset = {0};
+  qualset[(int)tag] = (1 << (int)(GUMBO_NAMESPACE_HTML));
+  return has_an_element_in_specific_scope(parser, qualset, false, (gumbo_tagset) { TAG(APPLET), 
         TAG(CAPTION), TAG(HTML), TAG(TABLE), TAG(TD), TAG(TH), TAG(MARQUEE),
-        TAG(OBJECT), TAG(TEMPLATE), TAG_MATHML(MI), TAG_MATHML(MO), TAG_MATHML(MN),
+        TAG(OBJECT), TAG_MATHML(MI), TAG_MATHML(MO), TAG_MATHML(MN),
         TAG_MATHML(MS), TAG_MATHML(MTEXT), TAG_MATHML(ANNOTATION_XML),
         TAG_SVG(FOREIGNOBJECT), TAG_SVG(DESC), TAG_SVG(TITLE), TAG(OL),
         TAG(UL) });
@@ -1468,22 +1348,27 @@ static bool has_an_element_in_list_scope(GumboParser* parser, GumboTag tag) {
 
 // http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#has-an-element-in-button-scope
 static bool has_an_element_in_button_scope(GumboParser* parser, GumboTag tag) {
-  return has_an_element_in_specific_scope(parser, 1, &tag, false, (gumbo_tagset) { TAG(APPLET),
+  gumbo_tagset qualset = {0};
+  qualset[(int) tag] = (1 << (int)(GUMBO_NAMESPACE_HTML));
+  return has_an_element_in_specific_scope(parser, qualset, false, (gumbo_tagset) { TAG(APPLET), 
         TAG(CAPTION), TAG(HTML), TAG(TABLE), TAG(TD), TAG(TH), TAG(MARQUEE),
-        TAG(OBJECT), TAG(TEMPLATE), TAG_MATHML(MI), TAG_MATHML(MO), TAG_MATHML(MN),
+        TAG(OBJECT), TAG_MATHML(MI), TAG_MATHML(MO), TAG_MATHML(MN),
         TAG_MATHML(MS), TAG_MATHML(MTEXT), TAG_MATHML(ANNOTATION_XML),
         TAG_SVG(FOREIGNOBJECT), TAG_SVG(DESC), TAG_SVG(TITLE), TAG(BUTTON) });
 }
 
 // http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#has-an-element-in-table-scope
 static bool has_an_element_in_table_scope(GumboParser* parser, GumboTag tag) {
-  return has_an_element_in_specific_scope(parser, 1, &tag, false, (gumbo_tagset) { TAG(HTML),
-        TAG(TABLE), TAG(TEMPLATE) });
+  gumbo_tagset qualset = {0};
+  qualset[(int) tag] = (1 << (int)(GUMBO_NAMESPACE_HTML));
+  return has_an_element_in_specific_scope(parser, qualset, false, (gumbo_tagset) { TAG(HTML), TAG(TABLE) });
 }
 
 // http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#has-an-element-in-select-scope
 static bool has_an_element_in_select_scope(GumboParser* parser, GumboTag tag) {
-  return has_an_element_in_specific_scope(parser, 1, &tag, true, (gumbo_tagset) { TAG(OPTGROUP), TAG(OPTION) });
+  gumbo_tagset qualset = {0};
+  qualset[(int) tag] = (1 << (int)(GUMBO_NAMESPACE_HTML));
+  return has_an_element_in_specific_scope(parser, qualset, true, (gumbo_tagset) { TAG(OPTGROUP), TAG(OPTION) });
 }
 
 // http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#generate-implied-end-tags
@@ -1491,24 +1376,12 @@ static bool has_an_element_in_select_scope(GumboParser* parser, GumboTag tag) {
 // Pass GUMBO_TAG_LAST to not exclude any of them.
 static void generate_implied_end_tags(GumboParser* parser, GumboTag exception) {
   for (;
-       node_tag_in_set(get_current_node(parser), (gumbo_tagset) { TAG(DD),
-         TAG(DT), TAG(LI), TAG(OPTION), TAG(OPTGROUP), TAG(P), TAG(RP), TAG(RB),
-         TAG(RT), TAG(RTC)  }) &&
+       node_tag_in_set(get_current_node(parser), (gumbo_tagset) { TAG(DD), TAG(DT),
+             TAG(LI), TAG(OPTION), TAG(OPTGROUP), TAG(P), TAG(RP), TAG(RT) }) &&
        !node_html_tag_is(get_current_node(parser), exception);
        pop_current_node(parser));
 }
 
-// This is the "generate all implied end tags thoroughly" clause of the spec.
-// https://html.spec.whatwg.org/multipage/syntax.html#closing-elements-that-have-implied-end-tags
-static void generate_all_implied_end_tags_thoroughly(GumboParser* parser) {
-  for (;
-       node_tag_in_set(get_current_node(parser), (gumbo_tagset) { TAG(CAPTION),
-             TAG(COLGROUP), TAG(DD), TAG(DT), TAG(LI), TAG(OPTION), TAG(OPTGROUP),
-             TAG(P), TAG(RP), TAG(RT), TAG(RTC), TAG(TBODY), TAG(TD),
-             TAG(TFOOT), TAG(TH), TAG(HEAD), TAG(TR) });
-       pop_current_node(parser));
-}
-
 // This factors out the clauses relating to "act as if an end tag token with tag
 // name "table" had been seen.  Returns true if there's a table element in table
 // scope which was successfully closed, false if not and the token should be
@@ -1573,7 +1446,7 @@ static void close_current_select(GumboParser* parser) {
 // The list of nodes in the "special" category:
 // http://www.whatwg.org/specs/web-apps/current-work/complete/parsing.html#special
 static bool is_special_node(const GumboNode* node) {
-  assert(node->type == GUMBO_NODE_ELEMENT || node->type == GUMBO_NODE_TEMPLATE);
+  assert(node->type == GUMBO_NODE_ELEMENT);
   return node_tag_in_set(node, (gumbo_tagset)  { TAG(ADDRESS), TAG(APPLET), TAG(AREA),
         TAG(ARTICLE), TAG(ASIDE), TAG(BASE), TAG(BASEFONT), TAG(BGSOUND), TAG(BLOCKQUOTE),
         TAG(BODY), TAG(BR), TAG(BUTTON), TAG(CAPTION), TAG(CENTER), TAG(COL),
@@ -1585,8 +1458,8 @@ static bool is_special_node(const GumboNode* node) {
         TAG(LISTING), TAG(MARQUEE), TAG(MENU), TAG(META), TAG(NAV), TAG(NOEMBED),
         TAG(NOFRAMES), TAG(NOSCRIPT), TAG(OBJECT), TAG(OL), TAG(P), TAG(PARAM),
         TAG(PLAINTEXT), TAG(PRE), TAG(SCRIPT), TAG(SECTION), TAG(SELECT), TAG(STYLE),
-        TAG(SUMMARY), TAG(TABLE), TAG(TBODY), TAG(TD), TAG(TEMPLATE), TAG(TEXTAREA),
-        TAG(TFOOT), TAG(TH), TAG(THEAD), TAG(TITLE), TAG(TR), TAG(UL), TAG(WBR), TAG(XMP),
+        TAG(SUMMARY), TAG(TABLE), TAG(TBODY), TAG(TD), TAG(TEXTAREA), TAG(TFOOT),
+        TAG(TH), TAG(THEAD), TAG(TITLE), TAG(TR), TAG(UL), TAG(WBR), TAG(XMP), 
 
         TAG_MATHML(MI), TAG_MATHML(MO), TAG_MATHML(MN), TAG_MATHML(MS),
         TAG_MATHML(MTEXT), TAG_MATHML(ANNOTATION_XML),
@@ -1796,20 +1669,13 @@ static void remove_from_parent(GumboParser* parser, GumboNode* node) {
 
 // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-end.html#an-introduction-to-error-handling-and-strange-cases-in-the-parser
 // Also described in the "in body" handling for end formatting tags.
-static bool adoption_agency_algorithm(GumboParser* parser, GumboToken* token, GumboTag subject) {
+static bool adoption_agency_algorithm(
+    GumboParser* parser, GumboToken* token, GumboTag closing_tag) {
   GumboParserState* state = parser->_parser_state;
   gumbo_debug("Entering adoption agency algorithm.\n");
-  // Step 1.
-  GumboNode* current_node = get_current_node(parser);
-  if (current_node->v.element.tag_namespace == GUMBO_NAMESPACE_HTML &&
-      current_node->v.element.tag == subject &&
-      gumbo_vector_index_of(&state->_active_formatting_elements, current_node) == -1) {
-    pop_current_node(parser);
-    return false;
-  }
-  // Steps 2-4 & 20:
+  // Steps 1-3 & 16:
   for (int i = 0; i < 8; ++i) {
-    // Step 5.
+    // Step 4.
     GumboNode* formatting_node = NULL;
     int formatting_node_in_open_elements = -1;
     for (int j = state->_active_formatting_elements.length; --j >= 0; ) {
@@ -1819,13 +1685,13 @@ static bool adoption_agency_algorithm(GumboParser* parser, GumboToken* token, Gu
         // Last scope marker; abort the algorithm.
         return false;
       }
-      if (node_html_tag_is(current_node, subject)) {
+      if (current_node->type == GUMBO_NODE_ELEMENT && current_node->v.element.tag == closing_tag) {
         // Found it.
         formatting_node = current_node;
         formatting_node_in_open_elements = gumbo_vector_index_of(
-                                                                 &state->_open_elements, formatting_node);
+            &state->_open_elements, formatting_node);
         gumbo_debug("Formatting element of tag %s at %d.\n",
-                    gumbo_normalized_tagname(subject),
+                    gumbo_normalized_tagname(closing_tag),
                     formatting_node_in_open_elements);
         break;
       }
@@ -1838,23 +1704,18 @@ static bool adoption_agency_algorithm(GumboParser* parser, GumboToken* token, Gu
       return false;
     }
 
-    // Step 6
     if (formatting_node_in_open_elements == -1) {
       gumbo_debug("Formatting node not on stack of open elements.\n");
-      parser_add_parse_error(parser, token);
       gumbo_vector_remove(parser, formatting_node,
                           &state->_active_formatting_elements);
       return false;
     }
 
-    // Step 7
     if (!has_an_element_in_scope(parser, formatting_node->v.element.tag)) {
       parser_add_parse_error(parser, token);
       gumbo_debug("Element not in scope.\n");
       return false;
     }
-
-    // Step 8
     if (formatting_node != get_current_node(parser)) {
       parser_add_parse_error(parser, token);  // But continue onwards.
     }
@@ -1862,20 +1723,20 @@ static bool adoption_agency_algorithm(GumboParser* parser, GumboToken* token, Gu
     assert(!node_html_tag_is(formatting_node, GUMBO_TAG_HTML));
     assert(!node_html_tag_is(formatting_node, GUMBO_TAG_BODY));
 
-    // Step 9 & 10
+    // Step 5 & 6.
     GumboNode* furthest_block = NULL;
     for (int j = formatting_node_in_open_elements;
          j < state->_open_elements.length; ++j) {
       assert(j > 0);
       GumboNode* current = state->_open_elements.data[j];
       if (is_special_node(current)) {
-        // Step 9.
+        // Step 5.
         furthest_block = current;
         break;
       }
     }
     if (!furthest_block) {
-      // Step 10.
+      // Step 6.
       while (get_current_node(parser) != formatting_node) {
         pop_current_node(parser);
       }
@@ -1888,35 +1749,32 @@ static bool adoption_agency_algorithm(GumboParser* parser, GumboToken* token, Gu
     assert(!node_html_tag_is(furthest_block, GUMBO_TAG_HTML));
     assert(furthest_block);
 
-    // Step 11.
+    // Step 7.
     // Elements may be moved and reparented by this algorithm, so
     // common_ancestor is not necessarily the same as formatting_node->parent.
     GumboNode* common_ancestor =
-      state->_open_elements.data[gumbo_vector_index_of(
-                                                       &state->_open_elements, formatting_node) - 1];
+        state->_open_elements.data[gumbo_vector_index_of(
+            &state->_open_elements, formatting_node) - 1];
     gumbo_debug("Common ancestor tag = %s, furthest block tag = %s.\n",
                 gumbo_normalized_tagname(common_ancestor->v.element.tag),
                 gumbo_normalized_tagname(furthest_block->v.element.tag));
 
-    // Step 12.
+    // Step 8.
     int bookmark = gumbo_vector_index_of(
-                                         &state->_active_formatting_elements, formatting_node) + 1;
-    gumbo_debug("Bookmark at %d.\n", bookmark);
-    // Step 13.
+        &state->_active_formatting_elements, formatting_node);;
+    // Step 9.
     GumboNode* node = furthest_block;
     GumboNode* last_node = furthest_block;
     // Must be stored explicitly, in case node is removed from the stack of open
     // elements, to handle step 9.4.
     int saved_node_index = gumbo_vector_index_of(&state->_open_elements, node);
     assert(saved_node_index > 0);
-    // Step 13.1.
-    for (int j = 0;;) {
-      // Step 13.2.
-      ++j;
-      // Step 13.3.
+    // Step 9.1-9.3 & 9.11.
+    for (int j = 0; j < 3; ++j) {
+      // Step 9.4.
       int node_index = gumbo_vector_index_of(&state->_open_elements, node);
       gumbo_debug(
-                  "Current index: %d, last index: %d.\n", node_index, saved_node_index);
+          "Current index: %d, last index: %d.\n", node_index, saved_node_index);
       if (node_index == -1) {
         node_index = saved_node_index;
       }
@@ -1925,78 +1783,61 @@ static bool adoption_agency_algorithm(GumboParser* parser, GumboToken* token, Gu
       assert(node_index < state->_open_elements.capacity);
       node = state->_open_elements.data[node_index];
       assert(node->parent);
-      if (node == formatting_node) {
-        // Step 13.4.
-        break;
-      }
-      int formatting_index =
-        gumbo_vector_index_of(&state->_active_formatting_elements, node);
-      if (j > 3 && formatting_index != -1) {
-        // Step 13.5.
-        gumbo_debug(
-                    "Removing formatting element at %d.\n", formatting_index);
-        gumbo_vector_remove_at(
-                               parser,
-                               formatting_index,
-                               &state->_active_formatting_elements);
-        // Removing the element shifts all indices over by one, so we may need
-        // to move the bookmark.
-        if (formatting_index < bookmark) {
-          --bookmark;
-          gumbo_debug("Moving bookmark to %d.\n", bookmark);
-        }
-        continue;
-      }
-      if (formatting_index == -1) {
-        // Step 13.6.
+      // Step 9.5.
+      if (gumbo_vector_index_of(
+          &state->_active_formatting_elements, node) == -1) {
         gumbo_vector_remove_at(parser, node_index, &state->_open_elements);
         continue;
+      } else if (node == formatting_node) {
+        // Step 9.6.
+        break;
       }
-      // Step 13.7.
-      // "common ancestor as the intended parent" doesn't actually mean insert
-      // it into the common ancestor; that happens below.
+      // Step 9.7.
+      int formatting_index = gumbo_vector_index_of(
+          &state->_active_formatting_elements, node);
       node = clone_node(parser, node, GUMBO_INSERTION_ADOPTION_AGENCY_CLONED);
-      assert(formatting_index >= 0);
       state->_active_formatting_elements.data[formatting_index] = node;
-      assert(node_index >= 0);
       state->_open_elements.data[node_index] = node;
-      // Step 13.8.
+      // Step 9.8.
       if (last_node == furthest_block) {
         bookmark = formatting_index + 1;
-        gumbo_debug("Bookmark moved to %d.\n", bookmark);
         assert(bookmark <= state->_active_formatting_elements.length);
       }
-      // Step 13.9.
+      // Step 9.9.
       last_node->parse_flags |= GUMBO_INSERTION_ADOPTION_AGENCY_MOVED;
       remove_from_parent(parser, last_node);
       append_node(parser, node, last_node);
-      // Step 13.10.
+      // Step 9.10.
       last_node = node;
-    } // Step 13.11.
+    }
 
-    // Step 14.
+    // Step 10.
     gumbo_debug("Removing %s node from parent ",
                 gumbo_normalized_tagname(last_node->v.element.tag));
     remove_from_parent(parser, last_node);
     last_node->parse_flags |= GUMBO_INSERTION_ADOPTION_AGENCY_MOVED;
-    InsertionLocation location =
-      get_appropriate_insertion_location(parser, common_ancestor);
-    gumbo_debug("and inserting it into %s.\n",
-                gumbo_normalized_tagname(location.target->v.element.tag));
-    insert_node(parser, last_node, location);
+    if (node_tag_in_set(common_ancestor, (gumbo_tagset) { TAG(TABLE), TAG(TBODY),
+            TAG(TFOOT), TAG(THEAD), TAG(TR) })) {
+      gumbo_debug("and foster-parenting it.\n");
+      foster_parent_element(parser, last_node);
+    } else {
+      gumbo_debug("and inserting it into %s.\n",
+                  gumbo_normalized_tagname(common_ancestor->v.element.tag));
+      append_node(parser, common_ancestor, last_node);
+    }
 
-    // Step 15.
+    // Step 11.
     GumboNode* new_formatting_node = clone_node(
-                                                parser, formatting_node, GUMBO_INSERTION_ADOPTION_AGENCY_CLONED);
+        parser, formatting_node, GUMBO_INSERTION_ADOPTION_AGENCY_CLONED);
     formatting_node->parse_flags |= GUMBO_INSERTION_IMPLICIT_END_TAG;
 
-    // Step 16.  Instead of appending nodes one-by-one, we swap the children
+    // Step 12.  Instead of appending nodes one-by-one, we swap the children
     // vector of furthest_block with the empty children of new_formatting_node,
     // reducing memory traffic and allocations.  We still have to reset their
     // parent pointers, though.
     GumboVector temp = new_formatting_node->v.element.children;
     new_formatting_node->v.element.children =
-      furthest_block->v.element.children;
+        furthest_block->v.element.children;
     furthest_block->v.element.children = temp;
 
     temp = new_formatting_node->v.element.children;
@@ -2005,39 +1846,36 @@ static bool adoption_agency_algorithm(GumboParser* parser, GumboToken* token, Gu
       child->parent = new_formatting_node;
     }
 
-    // Step 17.
+    // Step 13.
     append_node(parser, furthest_block, new_formatting_node);
 
-    // Step 18.
+    // Step 14.
     // If the formatting node was before the bookmark, it may shift over all
     // indices after it, so we need to explicitly find the index and possibly
     // adjust the bookmark.
     int formatting_node_index = gumbo_vector_index_of(
-                                                      &state->_active_formatting_elements, formatting_node);
+        &state->_active_formatting_elements, formatting_node);
     assert(formatting_node_index != -1);
     if (formatting_node_index < bookmark) {
-      gumbo_debug(
-                  "Formatting node at %d is before bookmark at %d; decrementing.\n",
-                  formatting_node_index, bookmark);
       --bookmark;
     }
     gumbo_vector_remove_at(
-                           parser, formatting_node_index, &state->_active_formatting_elements);
+        parser, formatting_node_index, &state->_active_formatting_elements);
     assert(bookmark >= 0);
     assert(bookmark <= state->_active_formatting_elements.length);
     gumbo_vector_insert_at(parser, new_formatting_node, bookmark,
                            &state->_active_formatting_elements);
 
-    // Step 19.
+    // Step 15.
     gumbo_vector_remove(
-                        parser, formatting_node, &state->_open_elements);
+        parser, formatting_node, &state->_open_elements);
     int insert_at = gumbo_vector_index_of(
-                                          &state->_open_elements, furthest_block) + 1;
+        &state->_open_elements, furthest_block) + 1;
     assert(insert_at >= 0);
     assert(insert_at <= state->_open_elements.length);
     gumbo_vector_insert_at(
-                           parser, new_formatting_node, insert_at, &state->_open_elements);
-  } // Step 20.
+        parser, new_formatting_node, insert_at, &state->_open_elements);
+  }
   return true;
 }
 
@@ -2216,45 +2054,29 @@ static bool handle_in_head(GumboParser* parser, GumboToken* token) {
     assert(node_html_tag_is(head, GUMBO_TAG_HEAD));
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_HEAD);
     return true;
-  } else if (tag_in(token, kEndTag, (gumbo_tagset) { TAG(BODY), TAG(HTML), TAG(BR) })) {
-    pop_current_node(parser);
-    set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_HEAD);
-    parser->_parser_state->_reprocess_current_token = true;
-    return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_TEMPLATE)) {
-    insert_element_from_token(parser, token);
-    add_formatting_element(parser, &kActiveFormattingScopeMarker);
-    parser->_parser_state->_frameset_ok = false;
-    set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TEMPLATE);
-    push_template_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TEMPLATE);
-    return true;
-  } else if (tag_is(token, kEndTag, GUMBO_TAG_TEMPLATE)) {
-    if (!has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
-      parser_add_parse_error(parser, token);
-      ignore_token(parser);
-      return false;
-    }
-    generate_all_implied_end_tags_thoroughly(parser);
-    bool success = true;
-    if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_TEMPLATE)) {
-      parser_add_parse_error(parser, token);
-      success = false;
-    }
-    while (!node_html_tag_is(pop_current_node(parser), GUMBO_TAG_TEMPLATE));
-    clear_active_formatting_elements(parser);
-    pop_template_insertion_mode(parser);
-    reset_insertion_mode_appropriately(parser);
-    return success;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_HEAD) || (token->type == GUMBO_TOKEN_END_TAG)) {
+  } else if (tag_is(token, kStartTag, GUMBO_TAG_HEAD)) {
+    parser_add_parse_error(parser, token);
+    ignore_token(parser);
+    return false;
+  } else if (tag_is(token, kStartTag, GUMBO_TAG_HEAD) ||
+             (token->type == GUMBO_TOKEN_END_TAG &&
+              !tag_in(token, kEndTag, (gumbo_tagset) { TAG(BODY), TAG(HTML),
+                    TAG(BR) }))) {
+    parser_add_parse_error(parser, token);
+    return false;
+  } else if (tag_is(token, kStartTag, GUMBO_TAG_UNKNOWN) && token->v.start_tag.is_self_closing) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     return false;
   } else {
-    pop_current_node(parser);
+    const GumboNode* node = pop_current_node(parser);
+    assert(node_html_tag_is(node, GUMBO_TAG_HEAD));
+    AVOID_UNUSED_VARIABLE_WARNING(node);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_HEAD);
     parser->_parser_state->_reprocess_current_token = true;
     return true;
   }
+
   return true;
 }
 
@@ -2320,7 +2142,7 @@ static bool handle_after_head(GumboParser* parser, GumboToken* token) {
   } else if (tag_in(token, kStartTag, (gumbo_tagset) { TAG(BASE), TAG(BASEFONT),
           TAG(BGSOUND), TAG(LINK), TAG(META),
           TAG(NOFRAMES), TAG(SCRIPT), TAG(STYLE),
-          TAG(TEMPLATE), TAG(TITLE) })) {
+          TAG(TITLE) })) {
     parser_add_parse_error(parser, token);
     assert(state->_head_element != NULL);
     // This must be flushed before we push the head element on, as there may be
@@ -2330,8 +2152,6 @@ static bool handle_after_head(GumboParser* parser, GumboToken* token) {
     bool result = handle_in_head(parser, token);
     gumbo_vector_remove(parser, state->_head_element, &state->_open_elements);
     return result;
-  } else if (tag_is(token, kEndTag, GUMBO_TAG_TEMPLATE)) {
-    return handle_in_head(parser, token);
   } else if (tag_is(token, kStartTag, GUMBO_TAG_HEAD) ||
             (token->type == GUMBO_TOKEN_END_TAG &&
              !tag_in(token, kEndTag, (gumbo_tagset) { TAG(BODY), TAG(HTML), TAG(BR) }))) {
@@ -2346,23 +2166,28 @@ static bool handle_after_head(GumboParser* parser, GumboToken* token) {
   }
 }
 
-static GumboNode* destroy_node(GumboParser* parser, GumboNode* node) {
+static void destroy_node(GumboParser* parser, GumboNode* node) {
   switch (node->type) {
     case GUMBO_NODE_DOCUMENT:
       {
         GumboDocument* doc = &node->v.document;
+        for (int i = 0; i < doc->children.length; ++i) {
+          destroy_node(parser, doc->children.data[i]);
+        }
         gumbo_parser_deallocate(parser, (void*) doc->children.data);
         gumbo_parser_deallocate(parser, (void*) doc->name);
         gumbo_parser_deallocate(parser, (void*) doc->public_identifier);
         gumbo_parser_deallocate(parser, (void*) doc->system_identifier);
       }
       break;
-    case GUMBO_NODE_TEMPLATE:
     case GUMBO_NODE_ELEMENT:
       for (int i = 0; i < node->v.element.attributes.length; ++i) {
         gumbo_destroy_attribute(parser, node->v.element.attributes.data[i]);
       }
       gumbo_parser_deallocate(parser, node->v.element.attributes.data);
+      for (int i = 0; i < node->v.element.children.length; ++i) {
+        destroy_node(parser, node->v.element.children.data[i]);
+      }
       gumbo_parser_deallocate(parser, node->v.element.children.data);
       break;
     case GUMBO_NODE_TEXT:
@@ -2372,21 +2197,7 @@ static GumboNode* destroy_node(GumboParser* parser, GumboNode* node) {
       gumbo_parser_deallocate(parser, (void*) node->v.text.text);
       break;
   }
-  // Remove from the next/prev linked list.
-  GumboNode* prev = node->prev;
-  GumboNode* next = node->next;
-  if (prev != NULL) {
-    prev->next = next;
-  }
-  if (next != NULL) {
-    next->prev = prev;
-  }
-  if (parser->_parser_state && parser->_parser_state->_current_node == node) {
-    parser->_parser_state->_current_node = prev;
-  }
-
   gumbo_parser_deallocate(parser, node);
-  return next;
 }
 
 // http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#parsing-main-inbody
@@ -2415,24 +2226,20 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     ignore_token(parser);
     return false;
   } else if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
-    parser_add_parse_error(parser, token);
-    if (has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
-      ignore_token(parser);
-      return false;
-    }
     assert(parser->_output->root != NULL);
     assert(parser->_output->root->type == GUMBO_NODE_ELEMENT);
+    parser_add_parse_error(parser, token);
     merge_attributes(parser, token, parser->_output->root);
     return false;
   } else if (tag_in(token, kStartTag, (gumbo_tagset) { TAG(BASE), TAG(BASEFONT),
           TAG(BGSOUND), TAG(MENUITEM), TAG(LINK),
           TAG(META), TAG(NOFRAMES), TAG(SCRIPT),
-          TAG(STYLE), TAG(TEMPLATE), TAG(TITLE) } ) || tag_is(token, kEndTag, GUMBO_TAG_TEMPLATE)) {
+          TAG(STYLE), TAG(TITLE) } )) {
     return handle_in_head(parser, token);
   } else if (tag_is(token, kStartTag, GUMBO_TAG_BODY)) {
     parser_add_parse_error(parser, token);
     if (state->_open_elements.length < 2 ||
-        !node_html_tag_is(state->_open_elements.data[1], GUMBO_TAG_BODY) || has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
+        !node_html_tag_is(state->_open_elements.data[1], GUMBO_TAG_BODY)) {
       ignore_token(parser);
       return false;
     }
@@ -2484,11 +2291,9 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
               TAG(DT), TAG(LI), TAG(P), TAG(TBODY), TAG(TD), TAG(TFOOT), TAG(TH),
               TAG(THEAD), TAG(TR), TAG(BODY), TAG(HTML) } )) {
         parser_add_parse_error(parser, token);
+        return false;
       }
     }
-    if (get_current_template_insertion_mode(parser) != GUMBO_INSERTION_MODE_INITIAL) {
-      return handle_in_template(parser, token);
-    }
     return true;
   } else if (tag_in(token, kEndTag, (gumbo_tagset) { TAG(BODY), TAG(HTML) })) {
     if (!has_an_element_in_scope(parser, GUMBO_TAG_BODY)) {
@@ -2498,11 +2303,10 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     }
     bool success = true;
     for (int i = 0; i < state->_open_elements.length; ++i) {
-      if (!node_tag_in_set(state->_open_elements.data[i], (gumbo_tagset) {
-            TAG(DD), TAG(DT), TAG(LI), TAG(OPTGROUP), TAG(OPTION), TAG(P),
-            TAG(RB), TAG(RP), TAG(RT), TAG(RTC), TAG(TBODY), TAG(TD),
-            TAG(TFOOT), TAG(TH), TAG(THEAD), TAG(TR),
-            TAG(BODY), TAG(HTML) })) {
+      if (!node_tag_in_set(state->_open_elements.data[i], (gumbo_tagset) { TAG(DD),
+              TAG(DT), TAG(LI), TAG(OPTGROUP), TAG(OPTION), TAG(P), TAG(RP),
+              TAG(RT), TAG(TBODY), TAG(TD), TAG(TFOOT), TAG(TH), TAG(THEAD),
+              TAG(TR), TAG(BODY), TAG(HTML) })) {
         parser_add_parse_error(parser, token);
         success = false;
         break;
@@ -2520,7 +2324,7 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
   } else if (tag_in(token, kStartTag, (gumbo_tagset) { TAG(ADDRESS), TAG(ARTICLE),
           TAG(ASIDE), TAG(BLOCKQUOTE), TAG(CENTER), TAG(DETAILS), 
           TAG(DIR), TAG(DIV), TAG(DL), TAG(FIELDSET), TAG(FIGCAPTION),
-          TAG(FIGURE), TAG(FOOTER), TAG(HEADER), TAG(HGROUP), TAG(MENU), TAG(MAIN),
+          TAG(FIGURE), TAG(FOOTER), TAG(HEADER), TAG(HGROUP), TAG(MENU), 
           TAG(NAV), TAG(OL), TAG(P), TAG(SECTION), TAG(SUMMARY), TAG(UL) })) {
     bool result = maybe_implicitly_close_p_tag(parser, token);
     insert_element_from_token(parser, token);
@@ -2543,17 +2347,15 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     state->_frameset_ok = false;
     return result;
   } else if (tag_is(token, kStartTag, GUMBO_TAG_FORM)) {
-    if (state->_form_element != NULL  && !has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
+    if (state->_form_element != NULL) {
       gumbo_debug("Ignoring nested form.\n");
       parser_add_parse_error(parser, token);
       ignore_token(parser);
       return false;
     }
     bool result = maybe_implicitly_close_p_tag(parser, token);
-    GumboNode* form_element = insert_element_from_token(parser, token);
-    if (!has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
-      state->_form_element = form_element;
-    }
+    state->_form_element =
+        insert_element_from_token(parser, token);
     return result;
   } else if (tag_is(token, kStartTag, GUMBO_TAG_LI)) {
     maybe_implicitly_close_list_tag(parser, token, true);
@@ -2585,7 +2387,7 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
          TAG(ASIDE), TAG(BLOCKQUOTE), TAG(BUTTON), TAG(CENTER), TAG(DETAILS), 
          TAG(DIR), TAG(DIV), TAG(DL), TAG(FIELDSET), TAG(FIGCAPTION), 
          TAG(FIGURE), TAG(FOOTER), TAG(HEADER), TAG(HGROUP), TAG(LISTING),
-         TAG(MAIN), TAG(MENU), TAG(NAV), TAG(OL), TAG(PRE),
+         TAG(MENU), TAG(NAV), TAG(OL), TAG(PRE),
          TAG(SECTION), TAG(SUMMARY), TAG(UL) })) {
     GumboTag tag = token->v.end_tag;
     if (!has_an_element_in_scope(parser, tag)) {
@@ -2596,45 +2398,30 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     implicitly_close_tags(parser, token, GUMBO_NAMESPACE_HTML, token->v.end_tag);
     return true;
   } else if (tag_is(token, kEndTag, GUMBO_TAG_FORM)) {
-    if (has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
-      if (!has_an_element_in_scope(parser, GUMBO_TAG_FORM)) {
-        parser_add_parse_error(parser, token);
-        ignore_token(parser);
-        return false;
-      }
-      bool success = true;
-      generate_implied_end_tags(parser, GUMBO_TAG_LAST);
-      if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_FORM)) {
-        parser_add_parse_error(parser, token);
-        return false;
-      }
-      while(!node_html_tag_is(pop_current_node(parser), GUMBO_TAG_FORM));
-      return success;
-    } else {
-      bool result = true;
-      const GumboNode* node = state->_form_element;
-      assert(!node || node->type == GUMBO_NODE_ELEMENT);
-      state->_form_element = NULL;
-      if (!node || !has_node_in_scope(parser, node)) {
-        gumbo_debug("Closing an unopened form.\n");
-        parser_add_parse_error(parser, token);
-        ignore_token(parser);
-        return false;
-      }
-      // This differs from implicitly_close_tags because we remove *only* the
-      // <form> element; other nodes are left in scope.
-      generate_implied_end_tags(parser, GUMBO_TAG_LAST);
-      if (get_current_node(parser) != node) {
-        parser_add_parse_error(parser, token);
-        result = false;
-      }
-
-      GumboVector* open_elements = &state->_open_elements;
-      int index = gumbo_vector_index_of(open_elements, node);
-      assert(index >= 0);
-      gumbo_vector_remove_at(parser, index, open_elements);
-      return result;
+    bool result = true;
+    const GumboNode* node = state->_form_element;
+    assert(!node || node->type == GUMBO_NODE_ELEMENT);
+    state->_form_element = NULL;
+    if (!node || !has_node_in_scope(parser, node)) {
+      gumbo_debug("Closing an unopened form.\n");
+      parser_add_parse_error(parser, token);
+      ignore_token(parser);
+      return false;
     }
+    // This differs from implicitly_close_tags because we remove *only* the
+    // <form> element; other nodes are left in scope.
+    generate_implied_end_tags(parser, GUMBO_TAG_LAST);
+    if (get_current_node(parser) != node) {
+      parser_add_parse_error(parser, token);
+      result = false;
+    }
+
+    GumboVector* open_elements = &state->_open_elements;
+    int index = open_elements->length - 1;
+    for (; index >= 0 && open_elements->data[index] != node; --index);
+    assert(index >= 0);
+    gumbo_vector_remove_at(parser, index, open_elements);
+    return result;
   } else if (tag_is(token, kEndTag, GUMBO_TAG_P)) {
     if (!has_an_element_in_button_scope(parser, GUMBO_TAG_P)) {
       parser_add_parse_error(parser, token);
@@ -2661,11 +2448,10 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
       return false;
     }
     return implicitly_close_tags(parser, token, GUMBO_NAMESPACE_HTML, token_tag);
- } else if (tag_in(token, kEndTag, (gumbo_tagset) {
-       TAG(H1), TAG(H2), TAG(H3), TAG(H4), TAG(H5), TAG(H6) })) {
-    if (!has_an_element_in_scope_with_tagname(parser, 6, (GumboTag[]) {
-          GUMBO_TAG_H1, GUMBO_TAG_H2, GUMBO_TAG_H3,
-          GUMBO_TAG_H4, GUMBO_TAG_H5, GUMBO_TAG_H6})) {
+ } else if (tag_in(token, kEndTag, (gumbo_tagset) { TAG(H1), TAG(H2), TAG(H3),
+         TAG(H4), TAG(H5), TAG(H6) })) {
+    if (!has_an_element_in_scope_with_tagname(parser, (gumbo_tagset) { TAG(H1), TAG(H2), TAG(H3), TAG(H4),
+            TAG(H5), TAG(H6) })) {
       // No heading open; ignore the token entirely.
       parser_add_parse_error(parser, token);
       ignore_token(parser);
@@ -2806,8 +2592,7 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     return result;
   } else if (tag_is(token, kStartTag, GUMBO_TAG_ISINDEX)) {
     parser_add_parse_error(parser, token);
-    if (parser->_parser_state->_form_element != NULL &&
-        !has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
+    if (parser->_parser_state->_form_element != NULL) {
       ignore_token(parser);
       return false;
     }
@@ -2822,9 +2607,6 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
 
     GumboNode* form = insert_element_of_tag_type(
         parser, GUMBO_TAG_FORM, GUMBO_INSERTION_FROM_ISINDEX);
-    if (!has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
-      parser->_parser_state->_form_element = form;
-    }
     if (action_attr) {
       gumbo_vector_add(parser, action_attr, &form->v.element.attributes);
     }
@@ -2888,9 +2670,6 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
         parser, GUMBO_TAG_HR, GUMBO_INSERTION_FROM_ISINDEX);
     pop_current_node(parser);   // <hr>
     pop_current_node(parser);   // <form>
-    if (!has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
-      parser->_parser_state->_form_element = NULL;
-    }
     return false;
   } else if (tag_is(token, kStartTag, GUMBO_TAG_TEXTAREA)) {
     run_generic_parsing_algorithm(parser, token, GUMBO_LEX_RCDATA);
@@ -2932,17 +2711,12 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     reconstruct_active_formatting_elements(parser);
     insert_element_from_token(parser, token);
     return true;
-  } else if (tag_in(token, kStartTag, (gumbo_tagset) {
-        TAG(RB), TAG(RP), TAG(RT), TAG(RTC) })) {
+    } else if (tag_in(token, kStartTag, (gumbo_tagset) { TAG(RP), TAG(RT) })) {
     bool success = true;
-    GumboTag exception = tag_in(token, kStartTag, (gumbo_tagset) {
-        TAG(RT), TAG(RP) }) ? GUMBO_TAG_RTC : GUMBO_TAG_LAST;
     if (has_an_element_in_scope(parser, GUMBO_TAG_RUBY)) {
-      generate_implied_end_tags(parser, exception);
+      generate_implied_end_tags(parser, GUMBO_TAG_LAST);
     }
-    if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_RUBY) &&
-        !(exception == GUMBO_TAG_LAST ||
-          node_html_tag_is(get_current_node(parser), GUMBO_TAG_RTC))) {
+    if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_RUBY)) {
       parser_add_parse_error(parser, token);
       success = false;
     }
@@ -3113,8 +2887,7 @@ static bool handle_in_table(GumboParser* parser, GumboToken* token) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     return false;
-  } else if (tag_in(token, kStartTag, (gumbo_tagset) { TAG(STYLE), TAG(SCRIPT), TAG(TEMPLATE) }) ||
-             (tag_is(token, kEndTag, GUMBO_TAG_TEMPLATE))) {
+  } else if (tag_in(token, kStartTag, (gumbo_tagset) { TAG(STYLE), TAG(SCRIPT) })) {
     return handle_in_head(parser, token);
   } else if (tag_is(token, kStartTag, GUMBO_TAG_INPUT) &&
              attribute_matches(&token->v.start_tag.attributes,
@@ -3125,7 +2898,7 @@ static bool handle_in_table(GumboParser* parser, GumboToken* token) {
     return false;
   } else if (tag_is(token, kStartTag, GUMBO_TAG_FORM)) {
     parser_add_parse_error(parser, token);
-    if (state->_form_element || has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
+    if (state->_form_element) {
       ignore_token(parser);
       return false;
     }
@@ -3133,7 +2906,11 @@ static bool handle_in_table(GumboParser* parser, GumboToken* token) {
     pop_current_node(parser);
     return false;
   } else if (token->type == GUMBO_TOKEN_EOF) {
-    return handle_in_body(parser, token);
+    if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_HTML)) {
+      parser_add_parse_error(parser, token);
+      return false;
+    }
+    return true;
   } else {
     parser_add_parse_error(parser, token);
     state->_foster_parent_insertions = true;
@@ -3178,37 +2955,35 @@ static bool handle_in_table_text(GumboParser* parser, GumboToken* token) {
 
 // http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#parsing-main-incaption
 static bool handle_in_caption(GumboParser* parser, GumboToken* token) {
-  if (tag_is(token, kEndTag, GUMBO_TAG_CAPTION)) {
+  if (tag_in(token, kStartTag, (gumbo_tagset) { TAG(CAPTION), TAG(COL),
+          TAG(COLGROUP), TAG(TBODY), TAG(TD),
+          TAG(TFOOT), TAG(TH), TAG(THEAD), TAG(TR) }) ||
+    tag_in(token, kEndTag, (gumbo_tagset) { TAG(CAPTION), TAG(TABLE) })) {
     if (!has_an_element_in_table_scope(parser, GUMBO_TAG_CAPTION)) {
       parser_add_parse_error(parser, token);
       ignore_token(parser);
       return false;
-    } else {
-      generate_implied_end_tags(parser, GUMBO_TAG_LAST);
-      bool result = true;
-      if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_CAPTION)) {
-        parser_add_parse_error(parser, token);
-      }
-      while (!node_html_tag_is(pop_current_node(parser), GUMBO_TAG_CAPTION));
-      clear_active_formatting_elements(parser);
-      set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
-      return result;
     }
-  } else if (tag_in(token, kStartTag, (gumbo_tagset) { TAG(CAPTION), TAG(COL),
-          TAG(COLGROUP), TAG(TBODY), TAG(TD), TAG(TFOOT), TAG(TH), TAG(THEAD), TAG(TR) }) ||
-          (tag_is(token, kEndTag, GUMBO_TAG_TABLE))) {
-    if (!has_an_element_in_table_scope(parser, GUMBO_TAG_CAPTION)) {
+    if (!tag_is(token, kEndTag, GUMBO_TAG_CAPTION)) {
       parser_add_parse_error(parser, token);
-      ignore_token(parser);
-      return false;
+      parser->_parser_state->_reprocess_current_token = true;
+    }
+    generate_implied_end_tags(parser, GUMBO_TAG_LAST);
+    bool result = true;
+    if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_CAPTION)) {
+      parser_add_parse_error(parser, token);
+      while (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_CAPTION)) {
+        pop_current_node(parser);
+      }
+      result = false;
     }
-    while (!node_html_tag_is(pop_current_node(parser), GUMBO_TAG_CAPTION));
+    pop_current_node(parser);  // The <caption> itself.
     clear_active_formatting_elements(parser);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
-    parser->_parser_state->_reprocess_current_token = true;
-    return true;
-  } else if (tag_in(token, kEndTag, (gumbo_tagset) { TAG(BODY), TAG(COL), TAG(COLGROUP),
-          TAG(HTML), TAG(TBODY), TAG(TD), TAG(TFOOT), TAG(TH), TAG(THEAD), TAG(TR) } )) {
+    return result;
+  } else if (tag_in(token, kEndTag, (gumbo_tagset) { TAG(BODY), TAG(COL),
+          TAG(COLGROUP), TAG(HTML), TAG(TBODY), TAG(TD), TAG(TFOOT), 
+          TAG(TH), TAG(THEAD), TAG(TR) })) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     return false;
@@ -3236,33 +3011,24 @@ static bool handle_in_column_group(GumboParser* parser, GumboToken* token) {
     pop_current_node(parser);
     acknowledge_self_closing_tag(parser);
     return true;
-  } else if (tag_is(token, kEndTag, GUMBO_TAG_COLGROUP)) {
-    if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_COLGROUP)) {
-      parser_add_parse_error(parser, token);
-      ignore_token(parser);
-      return false;
-    }
-    pop_current_node(parser);
-    set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
-    return false;
   } else if (tag_is(token, kEndTag, GUMBO_TAG_COL)) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     return false;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_TEMPLATE) ||
-             tag_is(token, kEndTag, GUMBO_TAG_TEMPLATE)) {
-    return handle_in_head(parser, token);
-  } else if (token->type == GUMBO_TOKEN_EOF) {
-    return handle_in_body(parser, token);
+  } else if (token->type == GUMBO_TOKEN_EOF &&
+             get_current_node(parser) == parser->_output->root) {
+    return true;
   } else {
-    if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_COLGROUP)) {
+    if (get_current_node(parser) == parser->_output->root) {
       parser_add_parse_error(parser, token);
-      ignore_token(parser);
       return false;
     }
+    assert(node_html_tag_is(get_current_node(parser), GUMBO_TAG_COLGROUP));
     pop_current_node(parser);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
-    parser->_parser_state->_reprocess_current_token = true;
+    if (!tag_is(token, kEndTag, GUMBO_TAG_COLGROUP)) {
+      parser->_parser_state->_reprocess_current_token = true;
+    }
     return true;
   }
 }
@@ -3325,48 +3091,42 @@ static bool handle_in_row(GumboParser* parser, GumboToken* token) {
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_CELL);
     add_formatting_element(parser, &kActiveFormattingScopeMarker);
     return true;
-  } else if (tag_is(token, kEndTag, GUMBO_TAG_TR)) {
-    if (!has_an_element_in_table_scope(parser,GUMBO_TAG_TR)) {
-      parser_add_parse_error(parser, token);
-      ignore_token(parser);
-      return false;
-    } else {
-      clear_stack_to_table_row_context(parser);
-      pop_current_node(parser);
-      set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE_BODY);
-      return true;
-    }
-  } else if (tag_in(token, kStartTag, (gumbo_tagset) { TAG(CAPTION), TAG(COL), TAG(COLGROUP),
-          TAG(TBODY), TAG(TFOOT), TAG(THEAD), TAG(TR) }) || tag_is(token, kEndTag, GUMBO_TAG_TABLE)) {
-    if (!has_an_element_in_table_scope(parser,GUMBO_TAG_TR)) {
+  } else if (tag_in(token, kStartTag, (gumbo_tagset) { TAG(CAPTION), TAG(COLGROUP),
+          TAG(TBODY), TAG(TFOOT), TAG(THEAD), TAG(TR) }) ||
+    tag_in(token, kEndTag, (gumbo_tagset) { TAG(TR), TAG(TABLE),
+          TAG(TBODY), TAG(TFOOT), TAG(THEAD) })) {
+    // This case covers 4 clauses of the spec, each of which say "Otherwise, act
+    // as if an end tag with the tag name "tr" had been seen."  The differences
+    // are in error handling and whether the current token is reprocessed.
+    GumboTag desired_tag =
+      tag_in(token, kEndTag, (gumbo_tagset) { TAG(TBODY), TAG(TFOOT),
+            TAG(THEAD) })
+        ? token->v.end_tag : GUMBO_TAG_TR;
+    if (!has_an_element_in_table_scope(parser, desired_tag)) {
+      gumbo_debug("Bailing because there is no tag %s in table scope.\nOpen elements:",
+                 gumbo_normalized_tagname(desired_tag));
+      for (int i = 0; i < parser->_parser_state->_open_elements.length; ++i) {
+        const GumboNode* node = parser->_parser_state->_open_elements.data[i];
+        gumbo_debug("%s\n", gumbo_normalized_tagname(node->v.element.tag));
+      }
       parser_add_parse_error(parser, token);
       ignore_token(parser);
       return false;
-    } else {
-      clear_stack_to_table_row_context(parser);
-      pop_current_node(parser);
-      set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE_BODY);
-      parser->_parser_state->_reprocess_current_token = true;
-      return true;
     }
-  } else if (tag_in(token, kEndTag, (gumbo_tagset) { TAG(TBODY), TAG(TFOOT), TAG(THEAD) })) {
-    if (!has_an_element_in_table_scope(parser, token->v.end_tag) ||
-        (!has_an_element_in_table_scope(parser, GUMBO_TAG_TR))) {
-      parser_add_parse_error(parser, token);
-      ignore_token(parser);
-      return false;
-    } else {
-      clear_stack_to_table_row_context(parser);
-      pop_current_node(parser);
-      set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE_BODY);
+    clear_stack_to_table_row_context(parser);
+    GumboNode* last_element = pop_current_node(parser);
+    assert(node_html_tag_is(last_element, GUMBO_TAG_TR));
+    AVOID_UNUSED_VARIABLE_WARNING(last_element);
+    set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE_BODY);
+    if (!tag_is(token, kEndTag, GUMBO_TAG_TR)) {
       parser->_parser_state->_reprocess_current_token = true;
-      return true;
     }
-  } else if (tag_in(token, kEndTag, (gumbo_tagset) { TAG(BODY), TAG(CAPTION), TAG(COL),
-          TAG(COLGROUP), TAG(HTML), TAG(TD), TAG(TH) })) {
-      parser_add_parse_error(parser, token);
-      ignore_token(parser);
-      return false;
+    return true;
+  } else if (tag_in(token, kEndTag, (gumbo_tagset) { TAG(BODY), TAG(CAPTION),
+          TAG(COL), TAG(COLGROUP), TAG(HTML), TAG(TD), TAG(TH) })) {
+    parser_add_parse_error(parser, token);
+    ignore_token(parser);
+    return false;
   } else {
     return handle_in_table(parser, token);
   }
@@ -3378,7 +3138,6 @@ static bool handle_in_cell(GumboParser* parser, GumboToken* token) {
     GumboTag token_tag = token->v.end_tag;
     if (!has_an_element_in_table_scope(parser, token_tag)) {
       parser_add_parse_error(parser, token);
-      ignore_token(parser);
       return false;
     }
     return close_table_cell(parser, token, token_tag);
@@ -3494,11 +3253,14 @@ static bool handle_in_select(GumboParser* parser, GumboToken* token) {
       parser->_parser_state->_reprocess_current_token = true;
     }
     return false;
-  } else if (tag_in(token, kStartTag, (gumbo_tagset) { TAG(SCRIPT) , TAG(TEMPLATE) }) ||
-             tag_is(token, kEndTag, GUMBO_TAG_TEMPLATE)) {
+  } else if (tag_is(token, kStartTag, GUMBO_TAG_SCRIPT)) {
     return handle_in_head(parser, token);
   } else if (token->type == GUMBO_TOKEN_EOF) {
-    return handle_in_body(parser, token);
+    if (get_current_node(parser) != parser->_output->root) {
+      parser_add_parse_error(parser, token);
+      return false;
+    }
+    return true;
   } else {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
@@ -3517,16 +3279,14 @@ static bool handle_in_select_in_table(GumboParser* parser, GumboToken* token) {
   } else if (tag_in(token, kEndTag, (gumbo_tagset) { TAG(CAPTION), TAG(TABLE),
           TAG(TBODY), TAG(TFOOT), TAG(THEAD), TAG(TR), TAG(TD), TAG(TH) })) {
     parser_add_parse_error(parser, token);
-    if (!has_an_element_in_table_scope(parser, token->v.end_tag)) {
-      ignore_token(parser);
-      return false;
-    } else {
+    if (has_an_element_in_table_scope(parser, token->v.end_tag)) {
       close_current_select(parser);
-      // close_current_select already does the reset_insertion_mode_appropriately
-      // reset_insertion_mode_appropriately(parser);
+      reset_insertion_mode_appropriately(parser);
       parser->_parser_state->_reprocess_current_token = true;
-      return false;
+    } else {
+      ignore_token(parser);
     }
+    return false;
   } else {
     return handle_in_select(parser, token);
   }
@@ -3534,68 +3294,8 @@ static bool handle_in_select_in_table(GumboParser* parser, GumboToken* token) {
 
 // http://www.whatwg.org/specs/web-apps/current-work/multipage/tree-construction.html#parsing-main-intemplate
 static bool handle_in_template(GumboParser* parser, GumboToken* token) {
-  GumboParserState* state = parser->_parser_state;
-  if (token->type == GUMBO_TOKEN_WHITESPACE ||
-      token->type == GUMBO_TOKEN_CHARACTER ||
-      token->type == GUMBO_TOKEN_COMMENT ||
-      token->type == GUMBO_TOKEN_DOCTYPE) {
-    return handle_in_body(parser, token);
-  } else if (tag_in(token, kStartTag, (gumbo_tagset) { TAG(BASE), TAG(BASEFONT), TAG(BGSOUND),
-          TAG(LINK), TAG(META), TAG(NOFRAMES), TAG(SCRIPT), TAG(STYLE),
-          TAG(TEMPLATE), TAG(TITLE) }) ||
-             tag_is(token, kEndTag, GUMBO_TAG_TEMPLATE)) {
-    return handle_in_head(parser, token);
-  } else if (tag_in(token, kStartTag, (gumbo_tagset) { TAG(CAPTION), TAG(COLGROUP),
-          TAG(TBODY), TAG(TFOOT), TAG(THEAD) })) {
-    pop_template_insertion_mode(parser);
-    push_template_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
-    set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
-    state->_reprocess_current_token = true;
-    return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_COL)) {
-    pop_template_insertion_mode(parser);
-    push_template_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_COLUMN_GROUP);
-    set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_COLUMN_GROUP);
-    state->_reprocess_current_token = true;
-    return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_TR)) {
-    pop_template_insertion_mode(parser);
-    push_template_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE_BODY);
-    set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE_BODY);
-    state->_reprocess_current_token = true;
-    return true;
-  } else if (tag_in(token, kStartTag, (gumbo_tagset) { TAG(TD), TAG(TH) })) {
-    pop_template_insertion_mode(parser);
-    push_template_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_ROW);
-    set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_ROW);
-    state->_reprocess_current_token = true;
-    return true;
-  } else if (token->type == GUMBO_TOKEN_START_TAG) {
-    pop_template_insertion_mode(parser);
-    push_template_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_BODY);
-    set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_BODY);
-    state->_reprocess_current_token = true;
-    return true;
-  } else if (token->type == GUMBO_TOKEN_END_TAG) {
-    parser_add_parse_error(parser, token);
-    ignore_token(parser);
-    return false;
-  } else if (token->type == GUMBO_TOKEN_EOF) {
-    if (!has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
-      // Stop parsing.
-      return true;
-    }
-    parser_add_parse_error(parser, token);
-    while(!node_html_tag_is(pop_current_node(parser), GUMBO_TAG_TEMPLATE));
-    clear_active_formatting_elements(parser);
-    pop_template_insertion_mode(parser);
-    reset_insertion_mode_appropriately(parser);
-    state->_reprocess_current_token = true;
-    return false;
-  } else {
-    assert(0);
-    return false;
-  }
+  // TODO(jdtang): Implement this.
+  return true;
 }
 
 // http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#parsing-main-afterbody
@@ -3613,12 +3313,7 @@ static bool handle_after_body(GumboParser* parser, GumboToken* token) {
     ignore_token(parser);
     return false;
   } else if (tag_is(token, kEndTag, GUMBO_TAG_HTML)) {
-    /* fragment case: ignore the closing HTML token */
-    if (is_fragment_parser(parser)) {
-      parser_add_parse_error(parser, token);
-      ignore_token(parser);
-      return false;
-    }
+    // TODO(jdtang): Handle fragment parsing algorithm case.
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_AFTER_BODY);
     GumboNode* html = parser->_parser_state->_open_elements.data[0];
     assert(node_html_tag_is(html, GUMBO_TAG_HTML));
@@ -3659,8 +3354,9 @@ static bool handle_in_frameset(GumboParser* parser, GumboToken* token) {
       return false;
     }
     pop_current_node(parser);
-    if (!is_fragment_parser(parser) &&
-        !node_html_tag_is(get_current_node(parser), GUMBO_TAG_FRAMESET)) {
+    // TODO(jdtang): Add a condition to ignore this for the fragment parsing
+    // algorithm.
+    if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_FRAMESET)) {
       set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_FRAMESET);
     }
     return true;
@@ -3834,32 +3530,18 @@ static bool handle_in_foreign_content(GumboParser* parser, GumboToken* token) {
          token_has_attribute(token, "color") ||
          token_has_attribute(token, "face") ||
          token_has_attribute(token, "size")))) {
-
-    /* Parse error */
     parser_add_parse_error(parser, token);
-
-    /*
-     * Fragment case: If the parser was originally created for the HTML
-     * fragment parsing algorithm, then act as described in the "any other
-     * start tag" entry below.
-     */
-    if (!is_fragment_parser(parser)) {
-      do {
-        pop_current_node(parser);
-      } while(!(is_mathml_integration_point(get_current_node(parser)) ||
-                is_html_integration_point(get_current_node(parser)) ||
-                get_current_node(parser)->v.element.tag_namespace ==
-                GUMBO_NAMESPACE_HTML));
-      parser->_parser_state->_reprocess_current_token = true;
-      return false;
-    }
-
-    assert(token->type == GUMBO_TOKEN_START_TAG);
-  }
-
-  if (token->type == GUMBO_TOKEN_START_TAG) {
+    do {
+      pop_current_node(parser);
+    } while(!(is_mathml_integration_point(get_current_node(parser)) ||
+              is_html_integration_point(get_current_node(parser)) ||
+              get_current_node(parser)->v.element.tag_namespace ==
+              GUMBO_NAMESPACE_HTML));
+    parser->_parser_state->_reprocess_current_token = true;
+    return false;
+  } else if (token->type == GUMBO_TOKEN_START_TAG) {
     const GumboNamespaceEnum current_namespace =
-        get_adjusted_current_node(parser)->v.element.tag_namespace;
+        get_current_node(parser)->v.element.tag_namespace;
     if (current_namespace == GUMBO_NAMESPACE_MATHML) {
       adjust_mathml_attributes(parser, token);
     }
@@ -3948,10 +3630,8 @@ static bool handle_token(GumboParser* parser, GumboToken* token) {
     parser->_parser_state->_closed_html_tag = true;
   }
 
-  const GumboNode* current_node = get_adjusted_current_node(parser);
-  assert(!current_node ||
-         current_node->type == GUMBO_NODE_ELEMENT ||
-         current_node->type == GUMBO_NODE_TEMPLATE);
+  const GumboNode* current_node = get_current_node(parser);
+  assert(!current_node || current_node->type == GUMBO_NODE_ELEMENT);
   if (current_node) {
     gumbo_debug("Current node: <%s>.\n",
                 gumbo_normalized_tagname(current_node->v.element.tag));
@@ -3979,66 +3659,6 @@ static bool handle_token(GumboParser* parser, GumboToken* token) {
   }
 }
 
-static void fragment_parser_init(
-    GumboParser *parser, GumboTag fragment_ctx,
-    GumboNamespaceEnum fragment_namespace) {
-  GumboNode *root;
-  assert(fragment_ctx != GUMBO_TAG_LAST);
-
-  // 3
-  parser->_parser_state->_fragment_ctx = create_element(parser, fragment_ctx);
-  parser->_parser_state->_fragment_ctx->v.element.tag_namespace =
-    fragment_namespace;
-
-  // 4
-  if (fragment_namespace == GUMBO_NAMESPACE_HTML) {
-    // Non-HTML namespaces always start in the DATA state.
-    switch (fragment_ctx) {
-      case GUMBO_TAG_TITLE:
-      case GUMBO_TAG_TEXTAREA:
-        gumbo_tokenizer_set_state(parser, GUMBO_LEX_RCDATA);
-        break;
-
-      case GUMBO_TAG_STYLE:
-      case GUMBO_TAG_XMP:
-      case GUMBO_TAG_IFRAME:
-      case GUMBO_TAG_NOEMBED:
-      case GUMBO_TAG_NOFRAMES:
-        gumbo_tokenizer_set_state(parser, GUMBO_LEX_RAWTEXT);
-        break;
-
-      case GUMBO_TAG_SCRIPT:
-        gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT);
-        break;
-
-      case GUMBO_TAG_NOSCRIPT:
-        /* scripting is disabled in Gumbo, so leave the tokenizer
-         * in the default data state */
-        break;
-
-      case GUMBO_TAG_PLAINTEXT:
-        gumbo_tokenizer_set_state(parser, GUMBO_LEX_PLAINTEXT);
-        break;
-
-      default:
-        /* default data state */
-        break;
-    }
-  }
-
-  // 5. 6. 7.
-  root = insert_element_of_tag_type(parser, GUMBO_TAG_HTML, GUMBO_INSERTION_IMPLIED);
-  parser->_output->root = root;
-
-  // 8.
-  if (fragment_ctx == GUMBO_TAG_TEMPLATE) {
-    push_template_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TEMPLATE);
-  }
-
-  // 10.
-  reset_insertion_mode_appropriately(parser);
-}
-
 GumboOutput* gumbo_parse(const char* buffer) {
   return gumbo_parse_with_options(
       &kGumboDefaultOptions, buffer, strlen(buffer));
@@ -4046,27 +3666,11 @@ GumboOutput* gumbo_parse(const char* buffer) {
 
 GumboOutput* gumbo_parse_with_options(
     const GumboOptions* options, const char* buffer, size_t length) {
-  return gumbo_parse_fragment(
-      options, buffer, length, GUMBO_TAG_LAST, GUMBO_NAMESPACE_HTML);
-}
-
-GumboOutput* gumbo_parse_fragment(
-    const GumboOptions* options, const char* buffer, size_t length,
-    const GumboTag fragment_ctx, const GumboNamespaceEnum fragment_namespace) {
   GumboParser parser;
   parser._options = options;
-  parser_state_init(&parser);
-  // Must come after parser_state_init, since creating the document node must
-  // reference parser_state->_current_node.
   output_init(&parser);
-  // And this must come after output_init, because initializing the tokenizer
-  // reads the first character and that may cause a UTF-8 decode error
-  // (inserting into output->errors) if that's invalid.
   gumbo_tokenizer_state_init(&parser, buffer, length);
-
-  if (fragment_ctx != GUMBO_TAG_LAST) {
-    fragment_parser_init(&parser, fragment_ctx, fragment_namespace);
-  }
+  parser_state_init(&parser);
 
   GumboParserState* state = parser._parser_state;
   gumbo_debug("Parsing %.*s.\n", length, buffer);
@@ -4154,16 +3758,20 @@ GumboOutput* gumbo_parse_fragment(
   return parser._output;
 }
 
+void gumbo_destroy_node(GumboOptions* options, GumboNode* node) {
+  // Need a dummy GumboParser because the allocator comes along with the
+  // options object.
+  GumboParser parser;
+  parser._options = options;
+  destroy_node(&parser, node);
+}
+
 void gumbo_destroy_output(const GumboOptions* options, GumboOutput* output) {
   // Need a dummy GumboParser because the allocator comes along with the
   // options object.
   GumboParser parser;
-  parser._parser_state = NULL;
   parser._options = options;
-  GumboNode* current = output->document;
-  while (current) {
-    current = destroy_node(&parser, current);
-  }
+  destroy_node(&parser, output->document);
   for (int i = 0; i < output->errors.length; ++i) {
     gumbo_error_destroy(&parser, output->errors.data[i]);
   }