diff --git a/.travis.yml b/.travis.yml
index 37a40eb2..f8460d1e 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -9,9 +9,9 @@ os:
   - osx
 
 install:
-  - wget 'https://googletest.googlecode.com/files/gtest-1.6.0.zip'
-  - unzip gtest-1.6.0.zip
-  - ln -s gtest-1.6.0 gtest
+  - wget 'https://googletest.googlecode.com/files/gtest-1.7.0.zip'
+  - unzip gtest-1.7.0.zip
+  - ln -s gtest-1.7.0 gtest
   - sudo pip install BeautifulSoup
   - sudo pip install html5lib==0.95
   - ln -s `python -c 'import html5lib, os; print os.path.dirname(html5lib.__file__)'`/tests/testdata .
diff --git a/DEBUGGING.md b/DEBUGGING.md
index 262ba1f1..8b8a56df 100644
--- a/DEBUGGING.md
+++ b/DEBUGGING.md
@@ -48,6 +48,9 @@ $ gdb .libs/lt-gumbo_test core
 
 The same goes for core dumps in other example binaries.
 
+To run only a single unit test, pass the --gtest_filter='TestName' flag to the
+lt-gumbo_test binary.
+
 Assertions
 ==========
 
diff --git a/Makefile.am b/Makefile.am
index 59cc2bb1..ea914116 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -37,6 +37,15 @@ clean-local:
 
 endif !HAVE_SHARED_LIBGTEST
 
+src/tag_strings.h: src/tag.in
+	@sed 's/\(.*\)/"\1",/g' <$< >$@
+
+src/tag_enum.h: src/tag.in
+	@sed 's/\(.*\)/GUMBO_TAG_\U\1,/g;s/-/_/g' <$< >$@
+
+python/gumbo/gumboc_tags.py: src/tag.in
+	@sed -e '1i TagNames = [' -e 's/\(.*\)/\t"\U\1",/g' -e 's/-/_/g' -e "\$$a]" <$< >$@
+
 lib_LTLIBRARIES = libgumbo.la
 libgumbo_la_CFLAGS = -Wall
 libgumbo_la_LDFLAGS = -version-info 1:0:0 -no-undefined
@@ -55,6 +64,8 @@ libgumbo_la_SOURCES = \
 				src/string_piece.c \
 				src/string_piece.h \
 				src/tag.c \
+				src/tag_enum.h \
+				src/tag_strings.h \
 				src/token_type.h \
 				src/tokenizer.c \
 				src/tokenizer.h \
diff --git a/benchmarks/benchmark.cc b/benchmarks/benchmark.cc
index 9c2c1c86..31d2ab42 100644
--- a/benchmarks/benchmark.cc
+++ b/benchmarks/benchmark.cc
@@ -62,7 +62,7 @@ int main(int argc, char** argv) {
       clock_t start_time = clock();
       for (int i = 0; i < kNumReps; ++i) {
         GumboOutput* output = gumbo_parse(contents.c_str());
-        gumbo_destroy_output(&kGumboDefaultOptions, output);
+        gumbo_destroy_output(output);
       }
       clock_t end_time = clock();
       std::cout << filename << ": "
diff --git a/examples/clean_text.cc b/examples/clean_text.cc
index 25113118..2e01b080 100644
--- a/examples/clean_text.cc
+++ b/examples/clean_text.cc
@@ -66,5 +66,5 @@ int main(int argc, char** argv) {
 
   GumboOutput* output = gumbo_parse(contents.c_str());
   std::cout << cleantext(output->root) << std::endl;
-  gumbo_destroy_output(&kGumboDefaultOptions, output);
+  gumbo_destroy_output(output);
 }
diff --git a/examples/find_links.cc b/examples/find_links.cc
index d84231d3..c1b56e7a 100644
--- a/examples/find_links.cc
+++ b/examples/find_links.cc
@@ -62,5 +62,5 @@ int main(int argc, char** argv) {
 
   GumboOutput* output = gumbo_parse(contents.c_str());
   search_for_links(output->root);
-  gumbo_destroy_output(&kGumboDefaultOptions, output);
+  gumbo_destroy_output(output);
 }
diff --git a/examples/get_title.c b/examples/get_title.c
index 15f2e294..e6dcdece 100644
--- a/examples/get_title.c
+++ b/examples/get_title.c
@@ -88,6 +88,6 @@ int main(int argc, const char** argv) {
       &kGumboDefaultOptions, input, input_length);
   const char* title = find_title(output->root);
   printf("%s\n", title);
-  gumbo_destroy_output(&kGumboDefaultOptions, output);
+  gumbo_destroy_output(output);
   free(input);
 }
diff --git a/examples/positions_of_class.cc b/examples/positions_of_class.cc
index 646ea23b..01ba4f7e 100644
--- a/examples/positions_of_class.cc
+++ b/examples/positions_of_class.cc
@@ -88,5 +88,5 @@ int main(int argc, char** argv) {
   GumboOutput* output = gumbo_parse_with_options(
       &kGumboDefaultOptions, contents.data(), contents.length());
   search_for_class(output->root, contents, cls);
-  gumbo_destroy_output(&kGumboDefaultOptions, output);
+  gumbo_destroy_output(output);
 }
diff --git a/examples/prettyprint.cc b/examples/prettyprint.cc
index 95c6eccc..02e59afa 100644
--- a/examples/prettyprint.cc
+++ b/examples/prettyprint.cc
@@ -210,7 +210,7 @@ static std::string prettyprint_contents(GumboNode* node, int lvl, const std::str
       contents.append(val);
 
 
-    } else if (child->type == GUMBO_NODE_ELEMENT) {
+    } else if ((child->type == GUMBO_NODE_ELEMENT) || (child->type == GUMBO_NODE_TEMPLATE)) {
 
       std::string val = prettyprint(child, lvl, indent_chars);
 
@@ -351,5 +351,5 @@ int main(int argc, char** argv) {
   GumboOutput* output = gumbo_parse_with_options(&options, contents.data(), contents.length());
   std::string indent_chars = "  ";
   std::cout << prettyprint(output->document, 0, indent_chars) << std::endl;
-  gumbo_destroy_output(&kGumboDefaultOptions, output);
+  gumbo_destroy_output(output);
 }
diff --git a/examples/serialize.cc b/examples/serialize.cc
index b6da9fa7..d1a41611 100644
--- a/examples/serialize.cc
+++ b/examples/serialize.cc
@@ -188,7 +188,7 @@ static std::string serialize_contents(GumboNode* node) {
         contents.append(substitute_xml_entities_into_text(std::string(child->v.text.text)));
       }
 
-    } else if (child->type == GUMBO_NODE_ELEMENT) {
+    } else if (child->type == GUMBO_NODE_ELEMENT || child->type == GUMBO_NODE_TEMPLATE) {
       contents.append(serialize(child));
 
     } else if (child->type == GUMBO_NODE_WHITESPACE) {
@@ -283,5 +283,5 @@ int main(int argc, char** argv) {
 
   GumboOutput* output = gumbo_parse_with_options(&options, contents.data(), contents.length());
   std::cout << serialize(output->document) << std::endl;
-  gumbo_destroy_output(&kGumboDefaultOptions, output);
+  gumbo_destroy_output(output);
 }
diff --git a/python/gumbo/gumboc.py b/python/gumbo/gumboc.py
index d377d58c..b2e40abd 100644
--- a/python/gumbo/gumboc.py
+++ b/python/gumbo/gumboc.py
@@ -26,6 +26,7 @@
 import contextlib
 import ctypes
 import os.path
+import gumboc_tags
 
 _name_of_lib = 'libgumbo.so'
 if sys.platform.startswith('darwin'):
@@ -246,158 +247,12 @@ def to_url(self):
 
 
 class Tag(Enum):
-  _values_ = [
-      'HTML',
-      'HEAD',
-      'TITLE',
-      'BASE',
-      'LINK',
-      'META',
-      'STYLE',
-      'SCRIPT',
-      'NOSCRIPT',
-      'TEMPLATE',
-      'BODY',
-      'ARTICLE',
-      'SECTION',
-      'NAV',
-      'ASIDE',
-      'H1',
-      'H2',
-      'H3',
-      'H4',
-      'H5',
-      'H6',
-      'HGROUP',
-      'HEADER',
-      'FOOTER',
-      'ADDRESS',
-      'P',
-      'HR',
-      'PRE',
-      'BLOCKQUOTE',
-      'OL',
-      'UL',
-      'LI',
-      'DL',
-      'DT',
-      'DD',
-      'FIGURE',
-      'FIGCAPTION',
-      'MAIN',
-      'DIV',
-      'A',
-      'EM',
-      'STRONG',
-      'SMALL',
-      'S',
-      'CITE',
-      'Q',
-      'DFN',
-      'ABBR',
-      'DATA',
-      'TIME',
-      'CODE',
-      'VAR',
-      'SAMP',
-      'KBD',
-      'SUB',
-      'SUP',
-      'I',
-      'B',
-      'U',
-      'MARK',
-      'RUBY',
-      'RT',
-      'RP',
-      'BDI',
-      'BDO',
-      'SPAN',
-      'BR',
-      'WBR',
-      'INS',
-      'DEL',
-      'IMAGE',
-      'IMG',
-      'IFRAME',
-      'EMBED',
-      'OBJECT',
-      'PARAM',
-      'VIDEO',
-      'AUDIO',
-      'SOURCE',
-      'TRACK',
-      'CANVAS',
-      'MAP',
-      'AREA',
-      'MATH',
-      'MI',
-      'MO',
-      'MN',
-      'MS',
-      'MTEXT',
-      'MGLYPH',
-      'MALIGNMARK',
-      'ANNOTATION_XML',
-      'SVG',
-      'FOREIGNOBJECT',
-      'DESC',
-      'TABLE',
-      'CAPTION',
-      'COLGROUP',
-      'COL',
-      'TBODY',
-      'THEAD',
-      'TFOOT',
-      'TR',
-      'TD',
-      'TH',
-      'FORM',
-      'FIELDSET',
-      'LEGEND',
-      'LABEL',
-      'INPUT',
-      'BUTTON',
-      'SELECT',
-      'DATALIST',
-      'OPTGROUP',
-      'OPTION',
-      'TEXTAREA',
-      'KEYGEN',
-      'OUTPUT',
-      'PROGRESS',
-      'METER',
-      'DETAILS',
-      'SUMMARY',
-      'MENU',
-      'MENUITEM',
-      'APPLET',
-      'ACRONYM',
-      'BGSOUND',
-      'DIR',
-      'FRAME',
-      'FRAMESET',
-      'NOFRAMES',
-      'ISINDEX',
-      'LISTING',
-      'XMP',
-      'NEXTID',
-      'NOEMBED',
-      'PLAINTEXT',
-      'RB',
-      'STRIKE',
-      'BASEFONT',
-      'BIG',
-      'BLINK',
-      'CENTER',
-      'FONT',
-      'MARQUEE',
-      'MULTICOL',
-      'NOBR',
-      'SPACER',
-      'TT',
-      'UNKNOWN',
-      ]
+  @staticmethod
+  def from_str(tagname):
+    text_ptr = ctypes.c_char_p(tagname.encode('utf-8'))
+    return _tag_enum(text_ptr)
+
+  _values_ = gumboc_tags.TagNames + ['UNKNOWN', 'LAST']
 
 
 class Element(ctypes.Structure):
@@ -444,7 +299,8 @@ def __repr__(self):
 
 
 class NodeType(Enum):
-  _values_ = ['DOCUMENT', 'ELEMENT', 'TEXT', 'CDATA', 'COMMENT', 'WHITESPACE']
+  _values_ = ['DOCUMENT', 'ELEMENT', 'TEXT', 'CDATA',
+              'COMMENT', 'WHITESPACE', 'TEMPLATE']
 
 
 class NodeUnion(ctypes.Union):
@@ -463,7 +319,7 @@ def _contents(self):
     # __getattr__, so we factor it out to a helper.
     if self.type == NodeType.DOCUMENT:
       return self.v.document
-    elif self.type == NodeType.ELEMENT:
+    elif self.type in (NodeType.ELEMENT, NodeType.TEMPLATE):
       return self.v.element
     else:
       return self.v.text
@@ -496,11 +352,6 @@ def __repr__(self):
 
 class Options(ctypes.Structure):
   _fields_ = [
-      # TODO(jdtang): Allow the Python API to set the allocator/deallocator
-      # function.  Right now these are treated as opaque void pointers.
-      ('allocator', ctypes.c_void_p),
-      ('deallocator', ctypes.c_void_p),
-      ('userdata', ctypes.c_void_p),
       ('tab_stop', ctypes.c_int),
       ('stop_on_first_error', ctypes.c_bool),
       ('max_errors', ctypes.c_int),
@@ -515,10 +366,10 @@ class Output(ctypes.Structure):
       ('errors', Vector),
       ]
 
-
 @contextlib.contextmanager
 def parse(text, **kwargs):
   options = Options()
+  container = kwargs.get("inner_html", Tag.LAST)
   for field_name, _ in Options._fields_:
     try:
       setattr(options, field_name, kwargs[field_name])
@@ -529,11 +380,11 @@ def parse(text, **kwargs):
   # call, it creates a temporary buffer which is destroyed when the call
   # completes, and then the original_text pointers point into invalid memory.
   text_ptr = ctypes.c_char_p(text.encode('utf-8'))
-  output = _parse_with_options(ctypes.byref(options), text_ptr, len(text))
+  output = _parse_fragment(ctypes.byref(options), text_ptr, len(text), container)
   try:
     yield output
   finally:
-    _destroy_output(ctypes.byref(options), output)
+    _destroy_output(output)
 
 _DEFAULT_OPTIONS = Options.in_dll(_dll, 'kGumboDefaultOptions')
 
@@ -541,6 +392,10 @@ def parse(text, **kwargs):
 _parse_with_options.argtypes = [_Ptr(Options), ctypes.c_char_p, ctypes.c_size_t]
 _parse_with_options.restype = _Ptr(Output)
 
+_parse_fragment = _dll.gumbo_parse_fragment
+_parse_fragment.argtypes = [_Ptr(Options), ctypes.c_char_p, ctypes.c_size_t, Tag]
+_parse_fragment.restype = _Ptr(Output)
+
 _tag_from_original_text = _dll.gumbo_tag_from_original_text
 _tag_from_original_text.argtypes = [_Ptr(StringPiece)]
 _tag_from_original_text.restype = None
@@ -550,13 +405,17 @@ def parse(text, **kwargs):
 _normalize_svg_tagname.restype = ctypes.c_char_p
 
 _destroy_output = _dll.gumbo_destroy_output
-_destroy_output.argtypes = [_Ptr(Options), _Ptr(Output)]
+_destroy_output.argtypes = [_Ptr(Output)]
 _destroy_output.restype = None
 
 _tagname = _dll.gumbo_normalized_tagname
 _tagname.argtypes = [Tag]
 _tagname.restype = ctypes.c_char_p
 
+_tag_enum = _dll.gumbo_tag_enum
+_tag_enum.argtypes = [ctypes.c_char_p]
+_tag_enum.restype = Tag
+
 __all__ = ['StringPiece', 'SourcePosition', 'AttributeNamespace', 'Attribute',
            'Vector', 'AttributeVector', 'NodeVector', 'QuirksMode', 'Document',
            'Namespace', 'Tag', 'Element', 'Text', 'NodeType', 'Node',
diff --git a/python/gumbo/gumboc_tags.py b/python/gumbo/gumboc_tags.py
new file mode 100644
index 00000000..c715b8ad
--- /dev/null
+++ b/python/gumbo/gumboc_tags.py
@@ -0,0 +1,152 @@
+TagNames = [
+	"HTML",
+	"HEAD",
+	"TITLE",
+	"BASE",
+	"LINK",
+	"META",
+	"STYLE",
+	"SCRIPT",
+	"NOSCRIPT",
+	"TEMPLATE",
+	"BODY",
+	"ARTICLE",
+	"SECTION",
+	"NAV",
+	"ASIDE",
+	"H1",
+	"H2",
+	"H3",
+	"H4",
+	"H5",
+	"H6",
+	"HGROUP",
+	"HEADER",
+	"FOOTER",
+	"ADDRESS",
+	"P",
+	"HR",
+	"PRE",
+	"BLOCKQUOTE",
+	"OL",
+	"UL",
+	"LI",
+	"DL",
+	"DT",
+	"DD",
+	"FIGURE",
+	"FIGCAPTION",
+	"MAIN",
+	"DIV",
+	"A",
+	"EM",
+	"STRONG",
+	"SMALL",
+	"S",
+	"CITE",
+	"Q",
+	"DFN",
+	"ABBR",
+	"DATA",
+	"TIME",
+	"CODE",
+	"VAR",
+	"SAMP",
+	"KBD",
+	"SUB",
+	"SUP",
+	"I",
+	"B",
+	"U",
+	"MARK",
+	"RUBY",
+	"RT",
+	"RP",
+	"BDI",
+	"BDO",
+	"SPAN",
+	"BR",
+	"WBR",
+	"INS",
+	"DEL",
+	"IMAGE",
+	"IMG",
+	"IFRAME",
+	"EMBED",
+	"OBJECT",
+	"PARAM",
+	"VIDEO",
+	"AUDIO",
+	"SOURCE",
+	"TRACK",
+	"CANVAS",
+	"MAP",
+	"AREA",
+	"MATH",
+	"MI",
+	"MO",
+	"MN",
+	"MS",
+	"MTEXT",
+	"MGLYPH",
+	"MALIGNMARK",
+	"ANNOTATION_XML",
+	"SVG",
+	"FOREIGNOBJECT",
+	"DESC",
+	"TABLE",
+	"CAPTION",
+	"COLGROUP",
+	"COL",
+	"TBODY",
+	"THEAD",
+	"TFOOT",
+	"TR",
+	"TD",
+	"TH",
+	"FORM",
+	"FIELDSET",
+	"LEGEND",
+	"LABEL",
+	"INPUT",
+	"BUTTON",
+	"SELECT",
+	"DATALIST",
+	"OPTGROUP",
+	"OPTION",
+	"TEXTAREA",
+	"KEYGEN",
+	"OUTPUT",
+	"PROGRESS",
+	"METER",
+	"DETAILS",
+	"SUMMARY",
+	"MENU",
+	"MENUITEM",
+	"APPLET",
+	"ACRONYM",
+	"BGSOUND",
+	"DIR",
+	"FRAME",
+	"FRAMESET",
+	"NOFRAMES",
+	"ISINDEX",
+	"LISTING",
+	"XMP",
+	"NEXTID",
+	"NOEMBED",
+	"PLAINTEXT",
+	"RB",
+	"STRIKE",
+	"BASEFONT",
+	"BIG",
+	"BLINK",
+	"CENTER",
+	"FONT",
+	"MARQUEE",
+	"MULTICOL",
+	"NOBR",
+	"SPACER",
+	"TT",
+	"RTC",
+]
diff --git a/python/gumbo/html5lib_adapter.py b/python/gumbo/html5lib_adapter.py
index 2a968640..54d4fc17 100644
--- a/python/gumbo/html5lib_adapter.py
+++ b/python/gumbo/html5lib_adapter.py
@@ -58,7 +58,7 @@ def maybe_namespace(attr):
 
 
 def _convert_element(source_node):
-  if source_node.type != gumboc.NodeType.ELEMENT:
+  if source_node.type not in ( gumboc.NodeType.ELEMENT, gumboc.NodeType.TEMPLATE):
     # If-statement instead of assert so it runs with -O
     raise AssertionError(
         '_convert_element only works with elements; found %r' %
@@ -70,12 +70,12 @@ def _convert_element(source_node):
       }
 
 
-def _insert_root(treebuilder, source_node):
+def _insert_root(treebuilder, source_node, pop_element = True):
   treebuilder.insertRoot(_convert_element(source_node))
   for child_node in source_node.children:
     _insert_node(treebuilder, child_node)
-  treebuilder.openElements.pop()
-
+  if pop_element:
+    treebuilder.openElements.pop()
 
 def _insert_node(treebuilder, source_node):
   assert source_node.type != gumboc.NodeType.DOCUMENT
@@ -110,8 +110,24 @@ def parse(self, text_or_file, **kwargs):
         if node.type == gumboc.NodeType.COMMENT:
           self.tree.insertComment({'data': node.v.text.text.decode('utf-8')},
                                   self.tree.document)
-        elif node.type == gumboc.NodeType.ELEMENT:
+        elif node.type in (gumboc.NodeType.ELEMENT, gumboc.NodeType.TEMPLATE):
           _insert_root(self.tree, output.contents.root.contents)
         else:
           assert 'Only comments and <html> nodes allowed at the root'
       return self.tree.getDocument()
+
+  def parseFragment(self, text_or_file, inner_html, **kwargs):
+    try:
+      text = text_or_file.read()
+    except AttributeError:
+      # Assume a string.
+      text = text_or_file
+    inner_html = gumboc.Tag.from_str(inner_html)
+
+    with gumboc.parse(text, inner_html=inner_html, **kwargs) as output:
+      for node in output.contents.document.contents.children:
+        if node.type in (gumboc.NodeType.ELEMENT, gumboc.NodeType.TEMPLATE):
+          _insert_root(self.tree, output.contents.root.contents, False)
+        else:
+          assert 'Malformed fragment parse (??)'
+      return self.tree.getFragment()
diff --git a/python/gumbo/html5lib_adapter_test.py b/python/gumbo/html5lib_adapter_test.py
index 2ab8c619..16908f92 100644
--- a/python/gumbo/html5lib_adapter_test.py
+++ b/python/gumbo/html5lib_adapter_test.py
@@ -91,6 +91,22 @@ def convertExpected(data, stripChars):
       rv.append(line)
   return "\n".join(rv)
 
+def reformatTemplateContents(expected):
+ lines = expected.split('\n')
+ retval = []
+ template_indents = []
+ for line in lines:
+   indent = len(line) - len(line.strip())
+   if 'content' in line:
+     template_indents.append(indent)
+     continue
+   elif template_indents and indent <= template_indents[-1]:
+     template_indents.pop()
+   elif template_indents:
+     line = line[2 * len(template_indents):]
+   retval.append(line)
+ return '\n'.join(retval)
+
 
 class Html5libAdapterTest(unittest.TestCase):
   """Adapter between Gumbo and the html5lib tests.
@@ -106,11 +122,11 @@ class Html5libAdapterTest(unittest.TestCase):
   def impl(self, inner_html, input, expected, errors):
     p = html5lib_adapter.HTMLParser(
             tree=TREEBUILDER(namespaceHTMLElements=True))
-    if not inner_html:
-      # TODO(jdtang): Need to implement fragment parsing.
-      document = p.parse(StringIO.StringIO(input))
+
+    if inner_html:
+      document = p.parseFragment(StringIO.StringIO(input), inner_html)
     else:
-      return
+      document = p.parse(StringIO.StringIO(input))
 
     with warnings.catch_warnings():
       # Etree serializer in html5lib uses a deprecated getchildren() API.
diff --git a/python/gumbo/soup_adapter.py b/python/gumbo/soup_adapter.py
index 089f8918..9bfaed66 100644
--- a/python/gumbo/soup_adapter.py
+++ b/python/gumbo/soup_adapter.py
@@ -80,6 +80,7 @@ def add_text_internal(soup, element):
     _add_text(BeautifulSoup.CData),
     _add_text(BeautifulSoup.Comment),
     _add_text(BeautifulSoup.NavigableString),
+    _add_element,
     ]
 
 
diff --git a/setup.py b/setup.py
index 4f06749e..1c20cef5 100644
--- a/setup.py
+++ b/setup.py
@@ -1,14 +1,22 @@
 #!/usr/bin/env python
+import sys
 from setuptools import setup
 from setuptools.command.sdist import sdist
 
+_name_of_lib = 'libgumbo.so'
+if sys.platform.startswith('darwin'):
+    _name_of_lib = 'libgumbo.dylib'
+elif sys.platform.startswith('win'):
+    _name_of_lib = 'gumbo.dll'
+
 class CustomSdistCommand(sdist):
     """Customized Sdist command, to copy libgumbo.so into the Python directory
     so that it can be installed with `pip install`."""
     def run(self):
         try:
             import shutil
-            shutil.copyfile('.libs/libgumbo.so', 'python/gumbo/libgumbo.so')
+            shutil.copyfile('.libs/' + _name_of_lib,
+                'python/gumbo/' + _name_of_lib)
             sdist.run(self)
         except IOError as e:
             print(e)
@@ -172,6 +180,6 @@ def run(self):
       classifiers=CLASSIFIERS,
       packages=['gumbo'],
       package_dir={'': 'python'},
-      package_data={'gumbo': ['libgumbo.so']},
+      package_data={'gumbo': [_name_of_lib]},
       cmdclass={ 'sdist': CustomSdistCommand },
       zip_safe=False)
diff --git a/src/attribute.c b/src/attribute.c
index a008403d..9dc0eeed 100644
--- a/src/attribute.c
+++ b/src/attribute.c
@@ -22,6 +22,7 @@
 #include <strings.h>
 
 #include "util.h"
+#include "vector.h"
 
 struct GumboInternalParser;
 
@@ -36,9 +37,38 @@ GumboAttribute* gumbo_get_attribute(
   return NULL;
 }
 
-void gumbo_destroy_attribute(
-    struct GumboInternalParser* parser, GumboAttribute* attribute) {
-  gumbo_parser_deallocate(parser, (void*) attribute->name);
-  gumbo_parser_deallocate(parser, (void*) attribute->value);
-  gumbo_parser_deallocate(parser, (void*) attribute);
+void gumbo_set_attribute_value(GumboAttribute *attr, const char *value)
+{
+  gumbo_free((void *)attr->value);
+  attr->value = gumbo_strdup(value);
+  attr->original_value = kGumboEmptyString;
+  attr->value_start = kGumboEmptySourcePosition;
+  attr->value_end = kGumboEmptySourcePosition;
+}
+
+void gumbo_set_attribute(
+    GumboVector *attributes, const char *name, const char *value)
+{
+  GumboAttribute *attr = gumbo_get_attribute(attributes, name);
+
+  if (!attr) {
+    attr = gumbo_malloc(sizeof(GumboAttribute));
+    attr->value = NULL;
+    attr->attr_namespace = GUMBO_ATTR_NAMESPACE_NONE;
+
+    attr->name = gumbo_strdup(name);
+    attr->original_name = kGumboEmptyString;
+    attr->name_start = kGumboEmptySourcePosition;
+    attr->name_end = kGumboEmptySourcePosition;
+
+    gumbo_vector_add(attr, attributes);
+  }
+
+  gumbo_set_attribute_value(attr, value);
+}
+
+void gumbo_destroy_attribute(GumboAttribute* attribute) {
+  gumbo_free((void*) attribute->name);
+  gumbo_free((void*) attribute->value);
+  gumbo_free((void*) attribute);
 }
diff --git a/src/attribute.h b/src/attribute.h
index f9b8aea5..67dd12a0 100644
--- a/src/attribute.h
+++ b/src/attribute.h
@@ -25,10 +25,28 @@ extern "C" {
 
 struct GumboInternalParser;
 
-// Release the memory used for an GumboAttribute, including the attribute
-// itself.
-void gumbo_destroy_attribute(
-    struct GumboInternalParser* parser, GumboAttribute* attribute);
+/*
+ * Search for a GumboAttribute object in a vector of
+ * attributes. Matching is performed case-insensitively
+ */
+GumboAttribute* gumbo_get_attribute(const GumboVector* attributes, const char* name);
+
+/*
+ * Set the "value" of the given GumboAttribute object
+ */
+void gumbo_set_attribute_value(GumboAttribute *attr, const char *value);
+
+/*
+ * Add an attribute to an existing vector of attributes;
+ * if the attribute already exists, it will be updated in-place
+ */
+void gumbo_set_attribute(GumboVector *attributes, const char *name, const char *value);
+
+/*
+ * Release the memory used for an GumboAttribute, including the attribute
+ * itself.
+ */
+void gumbo_destroy_attribute(GumboAttribute* attribute);
 
 #ifdef __cplusplus
 }
diff --git a/src/error.c b/src/error.c
index 3239a0b6..a0274d28 100644
--- a/src/error.c
+++ b/src/error.c
@@ -32,8 +32,7 @@ static const size_t kMessageBufferSize = 256;
 // Prints a formatted message to a StringBuffer.  This automatically resizes the
 // StringBuffer as necessary to fit the message.  Returns the number of bytes
 // written.
-static int print_message(GumboParser* parser, GumboStringBuffer* output,
-                         const char* format, ...) {
+static int print_message(GumboStringBuffer* output, const char* format, ...) {
   va_list args;
   va_start(args, format);
   int remaining_capacity = output->capacity - output->length;
@@ -46,7 +45,7 @@ static int print_message(GumboParser* parser, GumboStringBuffer* output,
     // enough.  In this case, we'll double the buffer size and hope it fits when
     // 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);
+    gumbo_string_buffer_reserve(output->capacity * 2, output);
     int result = vsnprintf(output->data + output->length,
                            remaining_capacity, format, args);
     va_end(args);
@@ -61,8 +60,7 @@ static int print_message(GumboParser* parser, GumboStringBuffer* output,
 #endif
 
   if (bytes_written > remaining_capacity) {
-    gumbo_string_buffer_reserve(
-        parser, output->capacity + bytes_written, output);
+    gumbo_string_buffer_reserve(output->capacity + bytes_written, output);
     remaining_capacity = output->capacity - output->length;
     bytes_written = vsnprintf(output->data + output->length,
                               remaining_capacity, format, args);
@@ -72,59 +70,58 @@ static int print_message(GumboParser* parser, GumboStringBuffer* output,
   return bytes_written;
 }
 
-static void print_tag_stack(
-    GumboParser* parser, const GumboParserError* error,
-    GumboStringBuffer* output) {
-  print_message(parser, output, "  Currently open tags: ");
+static void print_tag_stack(const GumboParserError* error, GumboStringBuffer* output) {
+  print_message(output, "  Currently open tags: ");
   for (int i = 0; i < error->tag_stack.length; ++i) {
     if (i) {
-      print_message(parser, output, ", ");
+      print_message(output, ", ");
     }
     GumboTag tag = (GumboTag) error->tag_stack.data[i];
-    print_message(parser, output, gumbo_normalized_tagname(tag));
+    print_message(output, gumbo_normalized_tagname(tag));
   }
-  gumbo_string_buffer_append_codepoint(parser, '.', output);
+  gumbo_string_buffer_append_codepoint('.', output);
 }
 
-static void handle_parser_error(GumboParser* parser,
-                                const GumboParserError* error,
-                                GumboStringBuffer* output) {
+static void handle_parser_error(
+		const GumboParserError* error,
+		GumboStringBuffer* output) {
   if (error->parser_state == GUMBO_INSERTION_MODE_INITIAL &&
       error->input_type != GUMBO_TOKEN_DOCTYPE) {
-    print_message(parser, output,
+    print_message(output,
                   "The doctype must be the first token in the document");
     return;
   }
 
   switch (error->input_type) {
     case GUMBO_TOKEN_DOCTYPE:
-      print_message(parser, output, "This is not a legal doctype");
+      print_message(output, "This is not a legal doctype");
       return;
     case GUMBO_TOKEN_COMMENT:
       // Should never happen; comments are always legal.
       assert(0);
       // But just in case...
-      print_message(parser, output, "Comments aren't legal here");
+      print_message(output, "Comments aren't legal here");
       return;
+    case GUMBO_TOKEN_CDATA:
     case GUMBO_TOKEN_WHITESPACE:
     case GUMBO_TOKEN_CHARACTER:
-      print_message(parser, output, "Character tokens aren't legal here");
+      print_message(output, "Character tokens aren't legal here");
       return;
     case GUMBO_TOKEN_NULL:
-      print_message(parser, output, "Null bytes are not allowed in HTML5");
+      print_message(output, "Null bytes are not allowed in HTML5");
       return;
     case GUMBO_TOKEN_EOF:
       if (error->parser_state == GUMBO_INSERTION_MODE_INITIAL) {
-        print_message(parser, output, "You must provide a doctype");
+        print_message(output, "You must provide a doctype");
       } else {
-        print_message(parser, output, "Premature end of file");
-        print_tag_stack(parser, error, output);
+        print_message(output, "Premature end of file");
+        print_tag_stack(error, output);
       }
       return;
     case GUMBO_TOKEN_START_TAG:
     case GUMBO_TOKEN_END_TAG:
-      print_message(parser, output, "That tag isn't allowed here");
-      print_tag_stack(parser, error, output);
+      print_message(output, "That tag isn't allowed here");
+      print_tag_stack(error, output);
       // TODO(jdtang): Give more specific messaging.
       return;
   }
@@ -159,53 +156,53 @@ GumboError* gumbo_add_error(GumboParser* parser) {
   if (max_errors >= 0 && parser->_output->errors.length >= max_errors) {
     return NULL;
   }
-  GumboError* error = gumbo_parser_allocate(parser, sizeof(GumboError));
-  gumbo_vector_add(parser, error, &parser->_output->errors);
+  GumboError* error = gumbo_malloc(sizeof(GumboError));
+  gumbo_vector_add(error, &parser->_output->errors);
   return error;
 }
 
 void gumbo_error_to_string(
-    GumboParser* parser, const GumboError* error, GumboStringBuffer* output) {
-  print_message(parser, output, "@%d:%d: ",
+    const GumboError* error, GumboStringBuffer* output) {
+  print_message(output, "@%d:%d: ",
                 error->position.line, error->position.column);
   switch (error->type) {
     case GUMBO_ERR_UTF8_INVALID:
-      print_message(parser, output, "Invalid UTF8 character 0x%x",
+      print_message(output, "Invalid UTF8 character 0x%x",
                error->v.codepoint);
       break;
     case GUMBO_ERR_UTF8_TRUNCATED:
-      print_message(parser, output,
+      print_message(output,
                "Input stream ends with a truncated UTF8 character 0x%x",
                error->v.codepoint);
       break;
     case GUMBO_ERR_NUMERIC_CHAR_REF_NO_DIGITS:
-      print_message(parser, output,
+      print_message(output,
                "No digits after &# in numeric character reference");
       break;
     case GUMBO_ERR_NUMERIC_CHAR_REF_WITHOUT_SEMICOLON:
-      print_message(parser, output,
+      print_message(output,
                "The numeric character reference &#%d should be followed "
                "by a semicolon", error->v.codepoint);
       break;
     case GUMBO_ERR_NUMERIC_CHAR_REF_INVALID:
-      print_message(parser, output,
+      print_message(output,
                "The numeric character reference &#%d; encodes an invalid "
                "unicode codepoint", error->v.codepoint);
       break;
     case GUMBO_ERR_NAMED_CHAR_REF_WITHOUT_SEMICOLON:
       // The textual data came from one of the literal strings in the table, and
       // so it'll be null-terminated.
-      print_message(parser, output,
+      print_message(output,
                "The named character reference &%.*s should be followed by a "
                "semicolon", (int) error->v.text.length, error->v.text.data);
       break;
     case GUMBO_ERR_NAMED_CHAR_REF_INVALID:
-      print_message(parser, output,
+      print_message(output,
                "The named character reference &%.*s; is not a valid entity name",
                (int) error->v.text.length, error->v.text.data);
       break;
     case GUMBO_ERR_DUPLICATE_ATTR:
-      print_message(parser, output,
+      print_message(output,
                "Attribute %s occurs multiple times, at positions %d and %d",
                error->v.duplicate_attr.name,
                error->v.duplicate_attr.original_index,
@@ -213,20 +210,19 @@ void gumbo_error_to_string(
       break;
     case GUMBO_ERR_PARSER:
     case GUMBO_ERR_UNACKNOWLEDGED_SELF_CLOSING_TAG:
-      handle_parser_error(parser, &error->v.parser, output);
+      handle_parser_error(&error->v.parser, output);
       break;
     default:
-      print_message(parser, output,
+      print_message(output,
                "Tokenizer error with an unimplemented error message");
       break;
   }
-  gumbo_string_buffer_append_codepoint(parser, '.', output);
+  gumbo_string_buffer_append_codepoint('.', output);
 }
 
-void gumbo_caret_diagnostic_to_string(
-    GumboParser* parser, const GumboError* error,
+void gumbo_caret_diagnostic_to_string(const GumboError* error,
     const char* source_text, GumboStringBuffer* output) {
-  gumbo_error_to_string(parser, error, output);
+  gumbo_error_to_string(error, output);
 
   const char* line_start =
       find_last_newline(source_text, error->original_text);
@@ -236,44 +232,44 @@ void gumbo_caret_diagnostic_to_string(
   original_line.data = line_start;
   original_line.length = line_end - line_start;
 
-  gumbo_string_buffer_append_codepoint(parser, '\n', output);
-  gumbo_string_buffer_append_string(parser, &original_line, output);
-  gumbo_string_buffer_append_codepoint(parser, '\n', output);
+  gumbo_string_buffer_append_codepoint('\n', output);
+  gumbo_string_buffer_append_string(&original_line, output);
+  gumbo_string_buffer_append_codepoint('\n', output);
   gumbo_string_buffer_reserve(
-      parser, output->length + error->position.column, output);
+      output->length + error->position.column, output);
   int num_spaces = error->position.column - 1;
   memset(output->data + output->length, ' ', num_spaces);
   output->length += num_spaces;
-  gumbo_string_buffer_append_codepoint(parser, '^', output);
-  gumbo_string_buffer_append_codepoint(parser, '\n', output);
+  gumbo_string_buffer_append_codepoint('^', output);
+  gumbo_string_buffer_append_codepoint('\n', output);
 }
 
 void gumbo_print_caret_diagnostic(
-    GumboParser* parser, const GumboError* error, const char* source_text) {
+    const GumboError* error, const char* source_text) {
   GumboStringBuffer text;
-  gumbo_string_buffer_init(parser, &text);
-  gumbo_caret_diagnostic_to_string(parser, error, source_text, &text);
+  gumbo_string_buffer_init(&text);
+  gumbo_caret_diagnostic_to_string(error, source_text, &text);
   printf("%.*s", (int) text.length, text.data);
-  gumbo_string_buffer_destroy(parser, &text);
+  gumbo_string_buffer_destroy(&text);
 }
 
-void gumbo_error_destroy(GumboParser* parser, GumboError* error) {
+void gumbo_error_destroy(GumboError* error) {
   if (error->type == GUMBO_ERR_PARSER ||
       error->type == GUMBO_ERR_UNACKNOWLEDGED_SELF_CLOSING_TAG) {
-    gumbo_vector_destroy(parser, &error->v.parser.tag_stack);
+    gumbo_vector_destroy(&error->v.parser.tag_stack);
   } else if (error->type == GUMBO_ERR_DUPLICATE_ATTR) {
-    gumbo_parser_deallocate(parser, (void*) error->v.duplicate_attr.name);
+    gumbo_free((void*) error->v.duplicate_attr.name);
   }
-  gumbo_parser_deallocate(parser, error);
+  gumbo_free(error);
 }
 
 void gumbo_init_errors(GumboParser* parser) {
-  gumbo_vector_init(parser, 5, &parser->_output->errors);
+  gumbo_vector_init(5, &parser->_output->errors);
 }
 
 void gumbo_destroy_errors(GumboParser* parser) {
   for (int i = 0; i < parser->_output->errors.length; ++i) {
-    gumbo_error_destroy(parser, parser->_output->errors.data[i]);
+    gumbo_error_destroy(parser->_output->errors.data[i]);
   }
-  gumbo_vector_destroy(parser, &parser->_output->errors);
+  gumbo_vector_destroy(&parser->_output->errors);
 }
diff --git a/src/error.h b/src/error.h
index c22006ac..1c685a9d 100644
--- a/src/error.h
+++ b/src/error.h
@@ -194,31 +194,27 @@ void gumbo_init_errors(struct GumboInternalParser* errors);
 void gumbo_destroy_errors(struct GumboInternalParser* errors);
 
 // Frees the memory used for a single GumboError.
-void gumbo_error_destroy(struct GumboInternalParser* parser, GumboError* error);
+void gumbo_error_destroy(GumboError* error);
 
 // Prints an error to a string.  This fills an empty GumboStringBuffer with a
 // freshly-allocated buffer containing the error message text.  The caller is
 // responsible for deleting the buffer.  (Note that the buffer is allocated with
 // the allocator specified in the GumboParser config and hence should be freed
-// by gumbo_parser_deallocate().)
-void gumbo_error_to_string(
-    struct GumboInternalParser* parser, const GumboError* error,
-    GumboStringBuffer* output);
+// by gumbo_free().)
+void gumbo_error_to_string(const GumboError* error, GumboStringBuffer* output);
 
 // Prints a caret diagnostic to a string.  This fills an empty GumboStringBuffer
 // with a freshly-allocated buffer containing the error message text.  The
 // caller is responsible for deleting the buffer.  (Note that the buffer is
 // allocated with the allocator specified in the GumboParser config and hence
 // should be freed by gumbo_parser_deallocate().)
-void gumbo_caret_diagnostic_to_string(
-    struct GumboInternalParser* parser, const GumboError* error,
+void gumbo_caret_diagnostic_to_string(const GumboError* error,
     const char* source_text, GumboStringBuffer* output);
 
 // Like gumbo_caret_diagnostic_to_string, but prints the text to stdout instead
 // of writing to a string.
 void gumbo_print_caret_diagnostic(
-    struct GumboInternalParser* parser, const GumboError* error,
-    const char* source_text);
+    const GumboError* error, const char* source_text);
 
 #ifdef __cplusplus
 }
diff --git a/src/gumbo.h b/src/gumbo.h
index a1b9a036..eeb46c7a 100644
--- a/src/gumbo.h
+++ b/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, void* element);
+int gumbo_vector_index_of(GumboVector* vector, const void* element);
 
 
 /**
@@ -157,171 +157,8 @@ int gumbo_vector_index_of(GumboVector* vector, void* element);
  * strings.
  */
 typedef enum {
-  // 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,
+  // Load all the tags from an external source
+# include "tag_enum.h"
   // 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.
@@ -364,9 +201,10 @@ 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.
+ * enum. The `tag` version expects `tagname` to be NULL-terminated
  */
 GumboTag gumbo_tag_enum(const char* tagname);
+GumboTag gumbo_tagn_enum(const char* tagname, int length);
 
 /**
  * Attribute namespaces.
@@ -461,10 +299,16 @@ 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
+  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
 } GumboNodeType;
 
 /**
@@ -718,18 +562,6 @@ typedef void (*GumboDeallocatorFunction)(void* userdata, void* ptr);
  * Use kGumboDefaultOptions for sensible defaults, and only set what you need.
  */
 typedef struct GumboInternalOptions {
-  /** A memory allocator function.  Default: malloc. */
-  GumboAllocatorFunction allocator;
-
-  /** A memory deallocator function. Default: free. */
-  GumboDeallocatorFunction deallocator;
-
-  /**
-   * An opaque object that's passed in as the first argument to all callbacks
-   * used by this library.  Default: NULL.
-   */
-  void* userdata;
-
   /**
    * The tab-stop size, for computing positions in source code that uses tabs.
    * Default: 8.
@@ -795,10 +627,34 @@ 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);
+
 /** Release the memory used for the parse tree & parse errors. */
-void gumbo_destroy_output(
-    const GumboOptions* options, GumboOutput* output);
+void gumbo_destroy_output(GumboOutput* output);
 
+/** Create a new node object, unatached to any documents */
+GumboNode* gumbo_create_node(GumboNodeType type);
+
+/** Release the memory used by a single node */
+void gumbo_destroy_node(GumboNode* node);
+
+/**
+ * Set the memory allocator to be used by the library.
+ * allocator_p needs to be a `realloc`-compatible API
+ */
+void gumbo_memory_set_allocator(void *(*allocator_p)(void *, size_t));
+
+/**
+ * Set the memory free function to be used by the library.
+ * free_p needs to be a `free`-compatible API
+ */
+void gumbo_memory_set_free(void (*free_p)(void *));
 
 #ifdef __cplusplus
 }
diff --git a/src/parser.c b/src/parser.c
index 004639dc..b507c997 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -46,19 +46,13 @@ typedef char gumbo_tagset[GUMBO_TAG_LAST];
   (tag < GUMBO_TAG_LAST && \
    tagset[(int)tag] == (1 << (int)namespace))
 
-
-static void* malloc_wrapper(void* unused, size_t size) {
-  return malloc(size);
-}
-
-static void free_wrapper(void* unused, void* ptr) {
-  free(ptr);
-}
+// 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*);
 
 const GumboOptions kGumboDefaultOptions = {
-  &malloc_wrapper,
-  &free_wrapper,
-  NULL,
   8,
   false,
   -1,
@@ -190,7 +184,7 @@ typedef struct _ReplacementEntry {
     { GUMBO_STRING(from), GUMBO_STRING(to) }
 
 // Static data for SVG attribute replacements.
-// http://www.whatwg.org/specs/web-apps/current-work/multipage/tree-construction.html#adjust-svg-attributes
+// https://html.spec.whatwg.org/multipage/syntax.html#creating-and-inserting-nodes
 static const ReplacementEntry kSvgAttributeReplacements[] = {
   REPLACEMENT_ENTRY("attributename", "attributeName"),
   REPLACEMENT_ENTRY("attributetype", "attributeType"),
@@ -198,12 +192,14 @@ static const ReplacementEntry kSvgAttributeReplacements[] = {
   REPLACEMENT_ENTRY("baseprofile", "baseProfile"),
   REPLACEMENT_ENTRY("calcmode", "calcMode"),
   REPLACEMENT_ENTRY("clippathunits", "clipPathUnits"),
+#ifndef GUMBO_HTML5_TIP
   REPLACEMENT_ENTRY("contentscripttype", "contentScriptType"),
   REPLACEMENT_ENTRY("contentstyletype", "contentStyleType"),
-  REPLACEMENT_ENTRY("diffuseconstant", "diffuseConstant"),
-  REPLACEMENT_ENTRY("edgemode", "edgeMode"),
   REPLACEMENT_ENTRY("externalresourcesrequired", "externalResourcesRequired"),
   REPLACEMENT_ENTRY("filterres", "filterRes"),
+#endif
+  REPLACEMENT_ENTRY("diffuseconstant", "diffuseConstant"),
+  REPLACEMENT_ENTRY("edgemode", "edgeMode"),
   REPLACEMENT_ENTRY("filterunits", "filterUnits"),
   REPLACEMENT_ENTRY("glyphref", "glyphRef"),
   REPLACEMENT_ENTRY("gradienttransform", "gradientTransform"),
@@ -345,7 +341,7 @@ typedef struct _TextNodeBufferState {
   // The source position of the start of this text node.
   GumboSourcePosition _start_position;
 
-  // The type of node that will be inserted (TEXT or WHITESPACE).
+  // The type of node that will be inserted (TEXT, CDATA, or WHITESPACE).
   GumboNodeType _type;
 } TextNodeBufferState;
 
@@ -371,6 +367,9 @@ 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;
 
@@ -450,8 +449,8 @@ static void set_frameset_not_ok(GumboParser* parser) {
   parser->_parser_state->_frameset_ok = false;
 }
 
-static GumboNode* create_node(GumboParser* parser, GumboNodeType type) {
-  GumboNode* node = gumbo_parser_allocate(parser, sizeof(GumboNode));
+GumboNode* gumbo_create_node(GumboNodeType type) {
+  GumboNode* node = gumbo_malloc(sizeof(GumboNode));
   node->parent = NULL;
   node->index_within_parent = -1;
   node->type = type;
@@ -459,11 +458,10 @@ static GumboNode* create_node(GumboParser* parser, GumboNodeType type) {
   return node;
 }
 
-static GumboNode* new_document_node(GumboParser* parser) {
-  GumboNode* document_node = create_node(parser, GUMBO_NODE_DOCUMENT);
+static GumboNode* new_document_node(void) {
+  GumboNode* document_node = gumbo_create_node(GUMBO_NODE_DOCUMENT);
   document_node->parse_flags = GUMBO_INSERTION_BY_PARSER;
-  gumbo_vector_init(
-      parser, 1, &document_node->v.document.children);
+  gumbo_vector_init(1, &document_node->v.document.children);
 
   // Must be initialized explicitly, as there's no guarantee that we'll see a
   // doc type token.
@@ -476,28 +474,29 @@ static GumboNode* new_document_node(GumboParser* parser) {
 }
 
 static void output_init(GumboParser* parser) {
-  GumboOutput* output = gumbo_parser_allocate(parser, sizeof(GumboOutput));
+  GumboOutput* output = gumbo_malloc(sizeof(GumboOutput));
   output->root = NULL;
-  output->document = new_document_node(parser);
+  output->document = new_document_node();
   parser->_output = output;
   gumbo_init_errors(parser);
 }
 
 static void parser_state_init(GumboParser* parser) {
   GumboParserState* parser_state =
-      gumbo_parser_allocate(parser, sizeof(GumboParserState));
+      gumbo_malloc(sizeof(GumboParserState));
   parser_state->_insertion_mode = GUMBO_INSERTION_MODE_INITIAL;
   parser_state->_reprocess_current_token = false;
   parser_state->_frameset_ok = true;
   parser_state->_ignore_next_linefeed = false;
   parser_state->_foster_parent_insertions = false;
   parser_state->_text_node._type = GUMBO_NODE_WHITESPACE;
-  gumbo_string_buffer_init(parser, &parser_state->_text_node._buffer);
-  gumbo_vector_init(parser, 10, &parser_state->_open_elements);
-  gumbo_vector_init(parser, 5, &parser_state->_active_formatting_elements);
-  gumbo_vector_init(parser, 5, &parser_state->_template_insertion_modes);
+  gumbo_string_buffer_init(&parser_state->_text_node._buffer);
+  gumbo_vector_init(10, &parser_state->_open_elements);
+  gumbo_vector_init(5, &parser_state->_active_formatting_elements);
+  gumbo_vector_init(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->_closed_body_tag = false;
   parser_state->_closed_html_tag = false;
@@ -506,17 +505,23 @@ static void parser_state_init(GumboParser* parser) {
 
 static void parser_state_destroy(GumboParser* parser) {
   GumboParserState* state = parser->_parser_state;
-  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);
+  if (state->_fragment_ctx)
+    gumbo_destroy_node(state->_fragment_ctx);
+  gumbo_vector_destroy(&state->_active_formatting_elements);
+  gumbo_vector_destroy(&state->_open_elements);
+  gumbo_vector_destroy(&state->_template_insertion_modes);
+  gumbo_string_buffer_destroy(&state->_text_node._buffer);
+  gumbo_free(state);
 }
 
 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) {
@@ -530,6 +535,13 @@ 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
@@ -550,55 +562,79 @@ 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 GumboNode* node, bool is_last) {
-  assert(node->type == GUMBO_NODE_ELEMENT);
-
-  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;
+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;
+
+  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;
 }
 
+
 // 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(open_elements->data[i], i == 0);
+        get_appropriate_insertion_mode(parser, i);
     if (mode != GUMBO_INSERTION_MODE_INITIAL) {
       set_insertion_mode(parser, mode);
       return;
@@ -628,12 +664,12 @@ static GumboError* parser_add_parse_error(GumboParser* parser, const GumboToken*
   }
   GumboParserState* state = parser->_parser_state;
   extra_data->parser_state = state->_insertion_mode;
-  gumbo_vector_init(parser, state->_open_elements.length,
+  gumbo_vector_init(state->_open_elements.length,
                    &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);
-    gumbo_vector_add(parser, (void*) node->v.element.tag,
+    assert(node->type == GUMBO_NODE_ELEMENT || node->type == GUMBO_NODE_TEMPLATE);
+    gumbo_vector_add((void*) node->v.element.tag,
                     &extra_data->tag_stack);
   }
   return error;
@@ -669,7 +705,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) {
+  if (node->type != GUMBO_NODE_ELEMENT && node->type != GUMBO_NODE_TEMPLATE) {
     return false;
   }
   return TAGSET_INCLUDES(tags, node->v.element.tag_namespace, node->v.element.tag);
@@ -678,7 +714,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 &&
+  return (node->type == GUMBO_NODE_ELEMENT || node->type == GUMBO_NODE_TEMPLATE) &&
     node->v.element.tag == tag &&
     node->v.element.tag_namespace == ns;
 }
@@ -689,6 +725,23 @@ 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((void*) mode, &parser->_parser_state->_template_insertion_modes);
+}
+
+static void pop_template_insertion_mode(GumboParser* parser) {
+  gumbo_vector_pop(&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) {
@@ -706,14 +759,70 @@ 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(
-    GumboParser* parser, GumboNode* parent, GumboNode* node) {
+static void append_node(GumboNode* parent, GumboNode* node) {
   assert(node->parent == NULL);
   assert(node->index_within_parent == -1);
   GumboVector* children;
-  if (parent->type == GUMBO_NODE_ELEMENT) {
+  if (parent->type == GUMBO_NODE_ELEMENT || parent->type == GUMBO_NODE_TEMPLATE) {
     children = &parent->v.element.children;
   } else {
     assert(parent->type == GUMBO_NODE_DOCUMENT);
@@ -721,70 +830,47 @@ static void append_node(
   }
   node->parent = parent;
   node->index_within_parent = children->length;
-  gumbo_vector_add(parser, (void*) node, children);
+  gumbo_vector_add((void*) node, children);
   assert(node->index_within_parent < children->length);
 }
 
-// Inserts a node at the specified index within its parent, updating the
+// Inserts a node at the specified InsertionLocation, updating the
 // "parent" and "index_within_parent" fields of it and all its siblings.
-static void insert_node(
-    GumboParser* parser, GumboNode* parent, int index, GumboNode* node) {
+// If the index of the location is -1, this calls append_node.
+static void insert_node(GumboNode* node, InsertionLocation location) {
   assert(node->parent == NULL);
   assert(node->index_within_parent == -1);
-  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);
-  }
-}
+  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);
+    }
 
-// 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;
+    assert(index >= 0);
+    assert(index < children->length);
+    node->parent = parent;
+    node->index_within_parent = index;
+    gumbo_vector_insert_at((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);
     }
+  } else {
+    append_node(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;
@@ -793,30 +879,31 @@ static void maybe_flush_text_node_buffer(GumboParser* parser) {
   }
 
   assert(buffer_state->_type == GUMBO_NODE_WHITESPACE ||
-         buffer_state->_type == GUMBO_NODE_TEXT);
-  GumboNode* text_node = create_node(parser, buffer_state->_type);
+         buffer_state->_type == GUMBO_NODE_TEXT ||
+         buffer_state->_type == GUMBO_NODE_CDATA);
+  GumboNode* text_node = gumbo_create_node(buffer_state->_type);
   GumboText* text_node_data = &text_node->v.text;
-  text_node_data->text = gumbo_string_buffer_to_string(
-      parser, &buffer_state->_buffer);
+  text_node_data->text = gumbo_string_buffer_to_string(&buffer_state->_buffer);
   text_node_data->original_text.data = buffer_state->_start_original_text;
   text_node_data->original_text.length =
       state->_current_token->original_text.data -
       buffer_state->_start_original_text;
   text_node_data->start_pos = buffer_state->_start_position;
-  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 {
-    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_destroy(parser, &buffer_state->_buffer);
-  gumbo_string_buffer_init(parser, &buffer_state->_buffer);
+  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.
+    gumbo_destroy_node(text_node);
+  } else {
+    insert_node(text_node, location);
+  }
+
+  gumbo_string_buffer_destroy(&buffer_state->_buffer);
+  gumbo_string_buffer_init(&buffer_state->_buffer);
   buffer_state->_type = GUMBO_NODE_WHITESPACE;
   assert(buffer_state->_buffer.length == 0);
 }
@@ -838,12 +925,12 @@ static GumboNode* pop_current_node(GumboParser* parser) {
         "Popping %s node.\n",
         gumbo_normalized_tagname(get_current_node(parser)->v.element.tag));
   }
-  GumboNode* current_node = gumbo_vector_pop(parser, &state->_open_elements);
+  GumboNode* current_node = gumbo_vector_pop(&state->_open_elements);
   if (!current_node) {
     assert(state->_open_elements.length == 0);
     return NULL;
   }
-  assert(current_node->type == GUMBO_NODE_ELEMENT);
+  assert(current_node->type == GUMBO_NODE_ELEMENT || current_node->type == GUMBO_NODE_TEMPLATE);
   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);
@@ -861,25 +948,25 @@ static GumboNode* pop_current_node(GumboParser* parser) {
 static void append_comment_node(
     GumboParser* parser, GumboNode* node, const GumboToken* token) {
   maybe_flush_text_node_buffer(parser);
-  GumboNode* comment = create_node(parser, GUMBO_NODE_COMMENT);
+  GumboNode* comment = gumbo_create_node(GUMBO_NODE_COMMENT);
   comment->type = GUMBO_NODE_COMMENT;
   comment->parse_flags = GUMBO_INSERTION_NORMAL;
   comment->v.text.text = token->v.text;
   comment->v.text.original_text = token->original_text;
   comment->v.text.start_pos = token->position;
-  append_node(parser, node, comment);
+  append_node(node, comment);
 }
 
 // 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) })) {
+  while (!node_tag_in_set(get_current_node(parser), (gumbo_tagset) { TAG(HTML), TAG(TR), TAG(TEMPLATE)})) {
     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) } )) {
+  while (!node_tag_in_set(get_current_node(parser), (gumbo_tagset) { TAG(HTML), TAG(TABLE), TAG(TEMPLATE) } )) {
     pop_current_node(parser);
   }
 }
@@ -887,35 +974,41 @@ 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(TFOOT), TAG(THEAD), TAG(TEMPLATE) })) {
     pop_current_node(parser);
   }
 }
 
 // Creates a parser-inserted element in the HTML namespace and returns it.
 static GumboNode* create_element(GumboParser* parser, GumboTag tag) {
-  GumboNode* node = create_node(parser, GUMBO_NODE_ELEMENT);
+  GumboNode* node = gumbo_create_node(GUMBO_NODE_ELEMENT);
   GumboElement* element = &node->v.element;
-  gumbo_vector_init(parser, 1, &element->children);
-  gumbo_vector_init(parser, 0, &element->attributes);
+  gumbo_vector_init(1, &element->children);
+  gumbo_vector_init(0, &element->attributes);
   element->tag = tag;
   element->tag_namespace = GUMBO_NAMESPACE_HTML;
   element->original_tag = kGumboEmptyString;
   element->original_end_tag = kGumboEmptyString;
-  element->start_pos = parser->_parser_state->_current_token->position;
+  element->start_pos = (parser->_parser_state->_current_token) ?
+    parser->_parser_state->_current_token->position : kGumboEmptySourcePosition;
   element->end_pos = kGumboEmptySourcePosition;
   return node;
 }
 
 // Constructs an element from the given start tag token.
 static GumboNode* create_element_from_token(
-    GumboParser* parser, GumboToken* token, GumboNamespaceEnum tag_namespace) {
+    GumboToken* token, GumboNamespaceEnum tag_namespace) {
   assert(token->type == GUMBO_TOKEN_START_TAG);
   GumboTokenStartTag* start_tag = &token->v.start_tag;
 
-  GumboNode* node = create_node(parser, GUMBO_NODE_ELEMENT);
+  GumboNodeType type = (
+      tag_namespace == GUMBO_NAMESPACE_HTML &&
+      start_tag->tag == GUMBO_TAG_TEMPLATE)
+        ? GUMBO_NODE_TEMPLATE : GUMBO_NODE_ELEMENT;
+
+  GumboNode* node = gumbo_create_node(type);
   GumboElement* element = &node->v.element;
-  gumbo_vector_init(parser, 1, &element->children);
+  gumbo_vector_init(1, &element->children);
   element->attributes = start_tag->attributes;
   element->tag = start_tag->tag;
   element->tag_namespace = tag_namespace;
@@ -950,21 +1043,10 @@ static void insert_element(GumboParser* parser, GumboNode* node,
   if (!is_reconstructing_formatting_elements) {
     maybe_flush_text_node_buffer(parser);
   }
-  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);
+  InsertionLocation location =
+    get_appropriate_insertion_location(parser, NULL);
+  insert_node(node, location);
+  gumbo_vector_add((void*) node, &state->_open_elements);
 }
 
 // Convenience method that combines create_element_from_token and
@@ -973,7 +1055,7 @@ static void insert_element(GumboParser* parser, GumboNode* node,
 static GumboNode* insert_element_from_token(
     GumboParser* parser, GumboToken* token) {
   GumboNode* element =
-      create_element_from_token(parser, token, GUMBO_NAMESPACE_HTML);
+      create_element_from_token(token, GUMBO_NAMESPACE_HTML);
   insert_element(parser, element, false);
   gumbo_debug("Inserting <%s> element (@%x) from token.\n",
              gumbo_normalized_tagname(element->v.element.tag), element);
@@ -998,7 +1080,7 @@ static GumboNode* insert_element_of_tag_type(
 static GumboNode* insert_foreign_element(
     GumboParser* parser, GumboToken* token, GumboNamespaceEnum tag_namespace) {
   assert(token->type == GUMBO_TOKEN_START_TAG);
-  GumboNode* element = create_element_from_token(parser, token, tag_namespace);
+  GumboNode* element = create_element_from_token(token, tag_namespace);
   insert_element(parser, element, false);
   if (token_has_attribute(token, "xmlns") &&
       !attribute_matches_case_sensitive(
@@ -1019,7 +1101,9 @@ static GumboNode* insert_foreign_element(
 
 static void insert_text_token(GumboParser* parser, GumboToken* token) {
   assert(token->type == GUMBO_TOKEN_WHITESPACE ||
-         token->type == GUMBO_TOKEN_CHARACTER);
+         token->type == GUMBO_TOKEN_CHARACTER ||
+         token->type == GUMBO_TOKEN_NULL ||
+         token->type == GUMBO_TOKEN_CDATA);
   TextNodeBufferState* buffer_state = &parser->_parser_state->_text_node;
   if (buffer_state->_buffer.length == 0) {
     // Initialize position fields.
@@ -1027,9 +1111,11 @@ static void insert_text_token(GumboParser* parser, GumboToken* token) {
     buffer_state->_start_position = token->position;
   }
   gumbo_string_buffer_append_codepoint(
-      parser, token->v.character, &buffer_state->_buffer);
+      token->v.character, &buffer_state->_buffer);
   if (token->type == GUMBO_TOKEN_CHARACTER) {
     buffer_state->_type = GUMBO_NODE_TEXT;
+  } else if (token->type == GUMBO_TOKEN_CDATA) {
+    buffer_state->_type = GUMBO_NODE_CDATA;
   }
   gumbo_debug("Inserting text token '%c'.\n", token->v.character);
 }
@@ -1111,10 +1197,10 @@ static void add_formatting_element(GumboParser* parser, const GumboNode* node) {
   if (num_identical_elements >= 3) {
     gumbo_debug("Noah's ark clause: removing element at %d.\n",
                 earliest_identical_element);
-    gumbo_vector_remove_at(parser, earliest_identical_element, elements);
+    gumbo_vector_remove_at(earliest_identical_element, elements);
   }
 
-  gumbo_vector_add(parser, (void*) node, elements);
+  gumbo_vector_add((void*) node, elements);
 }
 
 static bool is_open_element(GumboParser* parser, const GumboNode* node) {
@@ -1130,10 +1216,9 @@ static bool is_open_element(GumboParser* parser, const GumboNode* node) {
 // Clones attributes, tags, etc. of a node, but does not copy the content.  The
 // clone shares no structure with the original node: all owned strings and
 // values are fresh copies.
-GumboNode* clone_node(
-    GumboParser* parser, const GumboNode* node, GumboParseFlags reason) {
-  assert(node->type == GUMBO_NODE_ELEMENT);
-  GumboNode* new_node = gumbo_parser_allocate(parser, sizeof(GumboNode));
+GumboNode* clone_node(const GumboNode* node, GumboParseFlags reason) {
+  assert(node->type == GUMBO_NODE_ELEMENT || node->type == GUMBO_NODE_TEMPLATE);
+  GumboNode* new_node = gumbo_malloc(sizeof(GumboNode));
   *new_node = *node;
   new_node->parent = NULL;
   new_node->index_within_parent = -1;
@@ -1142,18 +1227,17 @@ GumboNode* clone_node(
   new_node->parse_flags &= ~GUMBO_INSERTION_IMPLICIT_END_TAG;
   new_node->parse_flags |= reason | GUMBO_INSERTION_BY_PARSER;
   GumboElement* element = &new_node->v.element;
-  gumbo_vector_init(parser, 1, &element->children);
+  gumbo_vector_init(1, &element->children);
 
   const GumboVector* old_attributes = &node->v.element.attributes;
-  gumbo_vector_init(parser, old_attributes->length, &element->attributes);
+  gumbo_vector_init(old_attributes->length, &element->attributes);
   for (int i = 0; i < old_attributes->length; ++i) {
     const GumboAttribute* old_attr = old_attributes->data[i];
-    GumboAttribute* attr =
-        gumbo_parser_allocate(parser, sizeof(GumboAttribute));
+    GumboAttribute* attr = gumbo_malloc(sizeof(GumboAttribute));
     *attr = *old_attr;
-    attr->name = gumbo_copy_stringz(parser, old_attr->name);
-    attr->value = gumbo_copy_stringz(parser, old_attr->value);
-    gumbo_vector_add(parser, attr, &element->attributes);
+    attr->name = gumbo_strdup(old_attr->name);
+    attr->value = gumbo_strdup(old_attr->value);
+    gumbo_vector_add(attr, &element->attributes);
   }
   return new_node;
 }
@@ -1199,10 +1283,12 @@ static void reconstruct_active_formatting_elements(GumboParser* parser) {
     assert(i < elements->length);
     element = elements->data[i];
     assert(element != &kActiveFormattingScopeMarker);
-    GumboNode* clone = clone_node(
-        parser, element, GUMBO_INSERTION_RECONSTRUCTED_FORMATTING_ELEMENT);
+    GumboNode* clone = clone_node(element, GUMBO_INSERTION_RECONSTRUCTED_FORMATTING_ELEMENT);
     // Step 9.
-    insert_element(parser, clone, true);
+    InsertionLocation location = get_appropriate_insertion_location(parser, NULL);
+    insert_node(clone, location);
+    gumbo_vector_add((void*) clone, &parser->_parser_state->_open_elements);
+
     // Step 10.
     elements->data[i] = clone;
     gumbo_debug("Reconstructed %s element at %d.\n",
@@ -1215,7 +1301,7 @@ static void clear_active_formatting_elements(GumboParser* parser) {
   int num_elements_cleared = 0;
   const GumboNode* node;
   do {
-    node = gumbo_vector_pop(parser, elements);
+    node = gumbo_vector_pop(elements);
     ++num_elements_cleared;
   } while(node && node != &kActiveFormattingScopeMarker);
   gumbo_debug("Cleared %d elements from active formatting list.\n",
@@ -1256,37 +1342,40 @@ 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.
-static bool has_an_element_in_specific_scope(GumboParser* parser, gumbo_tagset expected, bool negate, const gumbo_tagset tags) {
+// 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) {
   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) {
+    if (node->type != GUMBO_NODE_ELEMENT && node->type != GUMBO_NODE_TEMPLATE)
       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;
     }
-    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;
-    }
+
+    bool found = TAGSET_INCLUDES(tags, node_ns, node_tag);
+    if (negate != found)
+      return 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) } );
 }
 
 // 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) {
-  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), 
+  return has_an_element_in_specific_scope(parser, 1, &tag, 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(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) });
 }
@@ -1304,11 +1393,11 @@ static bool has_node_in_scope(GumboParser* parser, const GumboNode* node) {
     if (current == node) {
       return true;
     }
-    if (current->type != GUMBO_NODE_ELEMENT) {
+    if (current->type != GUMBO_NODE_ELEMENT && current->type != GUMBO_NODE_TEMPLATE) {
       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(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) } )) {
@@ -1321,21 +1410,19 @@ 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, 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) });
+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) });
 }
 
 // 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) {
-  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), 
+  return has_an_element_in_specific_scope(parser, 1, &tag, 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(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), TAG(OL),
         TAG(UL) });
@@ -1343,27 +1430,22 @@ 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) {
-  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), 
+  return has_an_element_in_specific_scope(parser, 1, &tag, 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(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), 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) {
-  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) });
+  return has_an_element_in_specific_scope(parser, 1, &tag, false, (gumbo_tagset) { TAG(HTML),
+        TAG(TABLE), TAG(TEMPLATE) });
 }
 
 // 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) {
-  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) });
+  return has_an_element_in_specific_scope(parser, 1, &tag, true, (gumbo_tagset) { TAG(OPTGROUP), TAG(OPTION) });
 }
 
 // http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#generate-implied-end-tags
@@ -1372,11 +1454,33 @@ static bool has_an_element_in_select_scope(GumboParser* parser, GumboTag tag) {
 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(RT) }) &&
+             TAG(LI), TAG(OPTION), TAG(OPTGROUP), TAG(P), TAG(RP), TAG(RB), TAG(RT), TAG(RTC) }) &&
        !node_html_tag_is(get_current_node(parser), exception);
        pop_current_node(parser));
 }
 
+
+
+
+
+#if 0
+// I can not find this clause anywhere in the current W3C spec for html5 syntax
+
+// This is the "generate all implied end tags thoroughly" clause of the spec.
+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(TBODY), TAG(TD), TAG(TFOOT),
+             TAG(TH), TAG(HEAD), TAG(TR) });
+       pop_current_node(parser));
+}
+#endif
+
+
+
+
+
 // 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
@@ -1441,7 +1545,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);
+  assert(node->type == GUMBO_NODE_ELEMENT || node->type == GUMBO_NODE_TEMPLATE);
   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),
@@ -1453,8 +1557,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(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(TEMPLATE), 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),
@@ -1515,8 +1619,7 @@ static void maybe_implicitly_close_list_tag(
   }
 }
 
-static void merge_attributes(
-    GumboParser* parser, GumboToken* token, GumboNode* node) {
+static void merge_attributes(GumboToken* token, GumboNode* node) {
   assert(token->type == GUMBO_TOKEN_START_TAG);
   assert(node->type == GUMBO_NODE_ELEMENT);
   const GumboVector* token_attr = &token->v.start_tag.attributes;
@@ -1528,7 +1631,7 @@ static void merge_attributes(
       // Ownership of the attribute is transferred by this gumbo_vector_add,
       // so it has to be nulled out of the original token so it doesn't get
       // double-deleted.
-      gumbo_vector_add(parser, attr, node_attr);
+      gumbo_vector_add(attr, node_attr);
       token_attr->data[i] = NULL;
     }
   }
@@ -1536,7 +1639,7 @@ static void merge_attributes(
   // with another token, so we need to free its memory.  The attributes that are
   // transferred need to be nulled-out in the vector above so that they aren't
   // double-deleted.
-  gumbo_token_destroy(parser, token);
+  gumbo_token_destroy(token);
 
 #ifndef NDEBUG
   // Mark this sentinel so the assertion in the main loop knows it's been
@@ -1559,7 +1662,7 @@ const char* gumbo_normalize_svg_tagname(const GumboStringPiece* tag) {
 // http://www.whatwg.org/specs/web-apps/current-work/multipage/tree-construction.html#adjust-foreign-attributes
 // This destructively modifies any matching attributes on the token and sets the
 // namespace appropriately.
-static void adjust_foreign_attributes(GumboParser* parser, GumboToken* token) {
+static void adjust_foreign_attributes(GumboToken* token) {
   assert(token->type == GUMBO_TOKEN_START_TAG);
   const GumboVector* attributes = &token->v.start_tag.attributes;
   for (int i = 0;
@@ -1571,15 +1674,16 @@ static void adjust_foreign_attributes(GumboParser* parser, GumboToken* token) {
     if (!attr) {
       continue;
     }
-    gumbo_parser_deallocate(parser, (void*) attr->name);
+    /* TODO:vmg refactor to use attribute helpers */
+    gumbo_free((void*) attr->name);
     attr->attr_namespace = entry->attr_namespace;
-    attr->name = gumbo_copy_stringz(parser, entry->local_name);
+    attr->name = gumbo_strdup(entry->local_name);
   }
 }
 
 // http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#adjust-svg-attributes
 // This destructively modifies any matching attributes on the token.
-static void adjust_svg_attributes(GumboParser* parser, GumboToken* token) {
+static void adjust_svg_attributes(GumboToken* token) {
   assert(token->type == GUMBO_TOKEN_START_TAG);
   const GumboVector* attributes = &token->v.start_tag.attributes;
   for (int i = 0;
@@ -1589,23 +1693,24 @@ static void adjust_svg_attributes(GumboParser* parser, GumboToken* token) {
     if (!attr) {
       continue;
     }
-    gumbo_parser_deallocate(parser, (void*) attr->name);
-    attr->name = gumbo_copy_stringz(parser, entry->to.data);
+    /* TODO:vmg refactor to use attribute helpers */
+    gumbo_free((void*) attr->name);
+    attr->name = gumbo_strdup(entry->to.data);
   }
 }
 
 // http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#adjust-mathml-attributes
 // Note that this may destructively modify the token with the new attribute
 // value.
-static void adjust_mathml_attributes(GumboParser* parser, GumboToken* token) {
+static void adjust_mathml_attributes(GumboToken* token) {
   assert(token->type == GUMBO_TOKEN_START_TAG);
   GumboAttribute* attr = gumbo_get_attribute(
       &token->v.start_tag.attributes, "definitionurl");
   if (!attr) {
     return;
   }
-  gumbo_parser_deallocate(parser, (void*) attr->name);
-  attr->name = gumbo_copy_stringz(parser, "definitionURL");
+  gumbo_free((void*) attr->name);
+  attr->name = gumbo_strdup("definitionURL");
 }
 
 static bool doctype_matches(
@@ -1640,7 +1745,7 @@ static bool maybe_add_doctype_error(
   return true;
 }
 
-static void remove_from_parent(GumboParser* parser, GumboNode* node) {
+static void remove_from_parent(GumboNode* node) {
   if (!node->parent) {
     // The node may not have a parent if, for example, it is a newly-cloned copy
     // of an active formatting element.  DOM manipulations continue with the
@@ -1653,7 +1758,7 @@ static void remove_from_parent(GumboParser* parser, GumboNode* node) {
   int index = gumbo_vector_index_of(children, node);
   assert(index != -1);
 
-  gumbo_vector_remove_at(parser, index, children);
+  gumbo_vector_remove_at(index, children);
   node->parent = NULL;
   node->index_within_parent = -1;
   for (int i = index; i < children->length; ++i) {
@@ -1701,7 +1806,7 @@ static bool adoption_agency_algorithm(
 
     if (formatting_node_in_open_elements == -1) {
       gumbo_debug("Formatting node not on stack of open elements.\n");
-      gumbo_vector_remove(parser, formatting_node,
+      gumbo_vector_remove(formatting_node,
                           &state->_active_formatting_elements);
       return false;
     }
@@ -1737,8 +1842,7 @@ static bool adoption_agency_algorithm(
       }
       // And the formatting element itself.
       pop_current_node(parser);
-      gumbo_vector_remove(parser, formatting_node,
-                          &state->_active_formatting_elements);
+      gumbo_vector_remove(formatting_node, &state->_active_formatting_elements);
       return false;
     }
     assert(!node_html_tag_is(furthest_block, GUMBO_TAG_HTML));
@@ -1781,7 +1885,7 @@ static bool adoption_agency_algorithm(
       // Step 9.5.
       if (gumbo_vector_index_of(
           &state->_active_formatting_elements, node) == -1) {
-        gumbo_vector_remove_at(parser, node_index, &state->_open_elements);
+        gumbo_vector_remove_at(node_index, &state->_open_elements);
         continue;
       } else if (node == formatting_node) {
         // Step 9.6.
@@ -1790,7 +1894,7 @@ static bool adoption_agency_algorithm(
       // 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);
+      node = clone_node(node, GUMBO_INSERTION_ADOPTION_AGENCY_CLONED);
       state->_active_formatting_elements.data[formatting_index] = node;
       state->_open_elements.data[node_index] = node;
       // Step 9.8.
@@ -1800,8 +1904,8 @@ static bool adoption_agency_algorithm(
       }
       // Step 9.9.
       last_node->parse_flags |= GUMBO_INSERTION_ADOPTION_AGENCY_MOVED;
-      remove_from_parent(parser, last_node);
-      append_node(parser, node, last_node);
+      remove_from_parent(last_node);
+      append_node(node, last_node);
       // Step 9.10.
       last_node = node;
     }
@@ -1809,21 +1913,17 @@ static bool adoption_agency_algorithm(
     // Step 10.
     gumbo_debug("Removing %s node from parent ",
                 gumbo_normalized_tagname(last_node->v.element.tag));
-    remove_from_parent(parser, last_node);
+    remove_from_parent(last_node);
     last_node->parse_flags |= GUMBO_INSERTION_ADOPTION_AGENCY_MOVED;
-    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);
-    }
+    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(last_node, location);
 
     // Step 11.
     GumboNode* new_formatting_node = clone_node(
-        parser, formatting_node, GUMBO_INSERTION_ADOPTION_AGENCY_CLONED);
+        formatting_node, GUMBO_INSERTION_ADOPTION_AGENCY_CLONED);
     formatting_node->parse_flags |= GUMBO_INSERTION_IMPLICIT_END_TAG;
 
     // Step 12.  Instead of appending nodes one-by-one, we swap the children
@@ -1842,7 +1942,7 @@ static bool adoption_agency_algorithm(
     }
 
     // Step 13.
-    append_node(parser, furthest_block, new_formatting_node);
+    append_node(furthest_block, new_formatting_node);
 
     // Step 14.
     // If the formatting node was before the bookmark, it may shift over all
@@ -1855,21 +1955,20 @@ static bool adoption_agency_algorithm(
       --bookmark;
     }
     gumbo_vector_remove_at(
-        parser, formatting_node_index, &state->_active_formatting_elements);
+        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,
+    gumbo_vector_insert_at(new_formatting_node, bookmark,
                            &state->_active_formatting_elements);
 
     // Step 15.
-    gumbo_vector_remove(
-        parser, formatting_node, &state->_open_elements);
+    gumbo_vector_remove(formatting_node, &state->_open_elements);
     int insert_at = gumbo_vector_index_of(
         &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);
+        new_formatting_node, insert_at, &state->_open_elements);
   }
   return true;
 }
@@ -1881,7 +1980,7 @@ static void ignore_token(GumboParser* parser) {
   // element, but if no element is emitted (as happens in non-verbatim-mode
   // when a token is ignored), we need to free it here to prevent a memory
   // leak.
-  gumbo_token_destroy(parser, token);
+  gumbo_token_destroy(token);
 #ifndef NDEBUG
   if (token->type == GUMBO_TOKEN_START_TAG) {
     // Mark this sentinel so the assertion in the main loop knows it's been
@@ -2049,29 +2148,47 @@ 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_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) {
+  } 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;
+    }
+    // can not find the next line in the spec
+    // generate_all_implied_end_tags_thoroughly(parser);
+    generate_implied_end_tags(parser, GUMBO_TAG_LAST);
+    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)) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     return false;
   } else {
-    const GumboNode* node = pop_current_node(parser);
-    assert(node_html_tag_is(node, GUMBO_TAG_HEAD));
-    AVOID_UNUSED_VARIABLE_WARNING(node);
+    pop_current_node(parser);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_HEAD);
     parser->_parser_state->_reprocess_current_token = true;
     return true;
   }
-
   return true;
 }
 
@@ -2137,16 +2254,18 @@ 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(TITLE) })) {
+          TAG(TEMPLATE), 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
     // pending character tokens that should be attached to the root.
     maybe_flush_text_node_buffer(parser);
-    gumbo_vector_add(parser, state->_head_element, &state->_open_elements);
+    gumbo_vector_add(state->_head_element, &state->_open_elements);
     bool result = handle_in_head(parser, token);
-    gumbo_vector_remove(parser, state->_head_element, &state->_open_elements);
+    gumbo_vector_remove(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) }))) {
@@ -2161,38 +2280,39 @@ static bool handle_after_head(GumboParser* parser, GumboToken* token) {
   }
 }
 
-static void destroy_node(GumboParser* parser, GumboNode* node) {
+extern void gumbo_destroy_node(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_destroy_node(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);
+        gumbo_free((void*) doc->children.data);
+        gumbo_free((void*) doc->name);
+        gumbo_free((void*) doc->public_identifier);
+        gumbo_free((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_destroy_attribute(node->v.element.attributes.data[i]);
       }
-      gumbo_parser_deallocate(parser, node->v.element.attributes.data);
+      gumbo_free(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_destroy_node(node->v.element.children.data[i]);
       }
-      gumbo_parser_deallocate(parser, node->v.element.children.data);
+      gumbo_free(node->v.element.children.data);
       break;
     case GUMBO_NODE_TEXT:
     case GUMBO_NODE_CDATA:
     case GUMBO_NODE_COMMENT:
     case GUMBO_NODE_WHITESPACE:
-      gumbo_parser_deallocate(parser, (void*) node->v.text.text);
+      gumbo_free((void*) node->v.text.text);
       break;
   }
-  gumbo_parser_deallocate(parser, node);
+  gumbo_free(node);
 }
 
 // http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#parsing-main-inbody
@@ -2207,7 +2327,8 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     reconstruct_active_formatting_elements(parser);
     insert_text_token(parser, token);
     return true;
-  } else if (token->type == GUMBO_TOKEN_CHARACTER) {
+  } else if (token->type == GUMBO_TOKEN_CHARACTER ||
+             token->type == GUMBO_TOKEN_CDATA) {
     reconstruct_active_formatting_elements(parser);
     insert_text_token(parser, token);
     set_frameset_not_ok(parser);
@@ -2220,25 +2341,29 @@ 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);
+    merge_attributes(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(TITLE) } )) {
+          TAG(STYLE), TAG(TEMPLATE), TAG(TITLE) } ) || tag_is(token, kEndTag, GUMBO_TAG_TEMPLATE)) {
     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)) {
+        !node_html_tag_is(state->_open_elements.data[1], GUMBO_TAG_BODY) || has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
       ignore_token(parser);
       return false;
     }
     state->_frameset_ok = false;
-    merge_attributes(parser, token, state->_open_elements.data[1]);
+    merge_attributes(token, state->_open_elements.data[1]);
     return false;
   } else if (tag_is(token, kStartTag, GUMBO_TAG_FRAMESET)) {
     parser_add_parse_error(parser, token);
@@ -2269,11 +2394,11 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     GumboVector* children = &parser->_output->root->v.element.children;
     for (int i = 0; i < children->length; ++i) {
       if (children->data[i] == body_node) {
-        gumbo_vector_remove_at(parser, i, children);
+        gumbo_vector_remove_at(i, children);
         break;
       }
     }
-    destroy_node(parser, body_node);
+    gumbo_destroy_node(body_node);
 
     // Insert the <frameset>, and switch the insertion mode.
     insert_element_from_token(parser, token);
@@ -2285,9 +2410,11 @@ 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)) {
@@ -2298,8 +2425,8 @@ 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(RP),
-              TAG(RT), TAG(TBODY), TAG(TD), TAG(TFOOT), TAG(TH), TAG(THEAD),
+              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) })) {
         parser_add_parse_error(parser, token);
         success = false;
@@ -2318,7 +2445,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(FIGURE), TAG(FOOTER), TAG(HEADER), TAG(HGROUP), TAG(MENU), TAG(MAIN),
           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);
@@ -2341,15 +2468,17 @@ 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) {
+    if (state->_form_element != NULL  && !has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
       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);
-    state->_form_element =
-        insert_element_from_token(parser, token);
+    GumboNode* form_element = insert_element_from_token(parser, token);
+    if (!has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
+      state->_form_element = form_element;
+    }
     return result;
   } else if (tag_is(token, kStartTag, GUMBO_TAG_LI)) {
     maybe_implicitly_close_list_tag(parser, token, true);
@@ -2381,7 +2510,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(MENU), TAG(NAV), TAG(OL), TAG(PRE),
+         TAG(MAIN), 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)) {
@@ -2392,30 +2521,45 @@ 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)) {
-    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;
-    }
+    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 = 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;
+      GumboVector* open_elements = &state->_open_elements;
+      int index = gumbo_vector_index_of(open_elements, node);
+      assert(index >= 0);
+      gumbo_vector_remove_at(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);
@@ -2442,10 +2586,11 @@ 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, (gumbo_tagset) { TAG(H1), TAG(H2), TAG(H3), TAG(H4),
-            TAG(H5), 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, 6, (GumboTag[]) {
+          GUMBO_TAG_H1, GUMBO_TAG_H2, GUMBO_TAG_H3,
+          GUMBO_TAG_H4, GUMBO_TAG_H5, GUMBO_TAG_H6})) {
       // No heading open; ignore the token entirely.
       parser_add_parse_error(parser, token);
       ignore_token(parser);
@@ -2481,9 +2626,9 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
       // listed in the spec.)
       if (find_last_anchor_index(parser, &last_a)) {
         void* last_element = gumbo_vector_remove_at(
-            parser, last_a, &state->_active_formatting_elements);
+            last_a, &state->_active_formatting_elements);
         gumbo_vector_remove(
-            parser, last_element, &state->_open_elements);
+            last_element, &state->_open_elements);
       }
       success = false;
     }
@@ -2586,7 +2731,8 @@ 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) {
+    if (parser->_parser_state->_form_element != NULL &&
+        !has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
       ignore_token(parser);
       return false;
     }
@@ -2601,8 +2747,11 @@ 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);
+      gumbo_vector_add(action_attr, &form->v.element.attributes);
     }
     insert_element_of_tag_type(parser, GUMBO_TAG_HR,
                                GUMBO_INSERTION_FROM_ISINDEX);
@@ -2616,16 +2765,16 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     text_state->_type = GUMBO_NODE_TEXT;
     if (prompt_attr) {
       int prompt_attr_length = strlen(prompt_attr->value);
-      gumbo_string_buffer_destroy(parser, &text_state->_buffer);
-      text_state->_buffer.data = gumbo_copy_stringz(parser, prompt_attr->value);
+      gumbo_string_buffer_destroy(&text_state->_buffer);
+      text_state->_buffer.data = gumbo_strdup(prompt_attr->value);
       text_state->_buffer.length = prompt_attr_length;
       text_state->_buffer.capacity = prompt_attr_length + 1;
-      gumbo_destroy_attribute(parser, prompt_attr);
+      gumbo_destroy_attribute(prompt_attr);
     } else {
       GumboStringPiece prompt_text = GUMBO_STRING(
           "This is a searchable index. Enter search keywords: ");
       gumbo_string_buffer_append_string(
-          parser, &prompt_text, &text_state->_buffer);
+          &prompt_text, &text_state->_buffer);
     }
 
     GumboNode* input = insert_element_of_tag_type(
@@ -2633,7 +2782,7 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     for (int i = 0; i < token_attrs->length; ++i) {
       GumboAttribute* attr = token_attrs->data[i];
       if (attr != prompt_attr && attr != action_attr && attr != name_attr) {
-        gumbo_vector_add(parser, attr, &input->v.element.attributes);
+        gumbo_vector_add(attr, &input->v.element.attributes);
       }
       token_attrs->data[i] = NULL;
     }
@@ -2643,20 +2792,19 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     // touching the attributes.
     ignore_token(parser);
 
-    GumboAttribute* name =
-        gumbo_parser_allocate(parser, sizeof(GumboAttribute));
+    GumboAttribute* name = gumbo_malloc(sizeof(GumboAttribute));
     GumboStringPiece name_str = GUMBO_STRING("name");
     GumboStringPiece isindex_str = GUMBO_STRING("isindex");
     name->attr_namespace = GUMBO_ATTR_NAMESPACE_NONE;
-    name->name = gumbo_copy_stringz(parser, "name");
-    name->value = gumbo_copy_stringz(parser, "isindex");
+    name->name = gumbo_strdup("name");
+    name->value = gumbo_strdup("isindex");
     name->original_name = name_str;
     name->original_value = isindex_str;
     name->name_start = kGumboEmptySourcePosition;
     name->name_end = kGumboEmptySourcePosition;
     name->value_start = kGumboEmptySourcePosition;
     name->value_end = kGumboEmptySourcePosition;
-    gumbo_vector_add(parser, name, &input->v.element.attributes);
+    gumbo_vector_add(name, &input->v.element.attributes);
 
     pop_current_node(parser);   // <input>
     pop_current_node(parser);   // <label>
@@ -2664,6 +2812,9 @@ 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);
@@ -2705,7 +2856,7 @@ 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(RP), TAG(RT) })) {
+  } else if (tag_in(token, kStartTag, (gumbo_tagset) { TAG(RB), TAG(RP), TAG(RTC) })) {
     bool success = true;
     if (has_an_element_in_scope(parser, GUMBO_TAG_RUBY)) {
       generate_implied_end_tags(parser, GUMBO_TAG_LAST);
@@ -2716,6 +2867,19 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     }
     insert_element_from_token(parser, token);
     return success;
+
+  } else if (tag_is(token, kStartTag, GUMBO_TAG_RT)) {
+    bool success = true;
+    if (has_an_element_in_scope(parser, GUMBO_TAG_RUBY)) {
+      generate_implied_end_tags(parser, GUMBO_TAG_RTC);
+    }
+    if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_RUBY) &&
+        (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_RTC))) {
+      parser_add_parse_error(parser, token);
+      success = false;
+    }
+    insert_element_from_token(parser, token);
+    return success;
   } else if (tag_is(token, kEndTag, GUMBO_TAG_BR)) {
     parser_add_parse_error(parser, token);
     reconstruct_active_formatting_elements(parser);
@@ -2725,8 +2889,8 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     return false;
   } else if (tag_is(token, kStartTag, GUMBO_TAG_MATH)) {
     reconstruct_active_formatting_elements(parser);
-    adjust_mathml_attributes(parser, token);
-    adjust_foreign_attributes(parser, token);
+    adjust_mathml_attributes(token);
+    adjust_foreign_attributes(token);
     insert_foreign_element(parser, token, GUMBO_NAMESPACE_MATHML);
     if (token->v.start_tag.is_self_closing) {
       pop_current_node(parser);
@@ -2735,8 +2899,8 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     return true;
   } else if (tag_is(token, kStartTag, GUMBO_TAG_SVG)) {
     reconstruct_active_formatting_elements(parser);
-    adjust_svg_attributes(parser, token);
-    adjust_foreign_attributes(parser, token);
+    adjust_svg_attributes(token);
+    adjust_foreign_attributes(token);
     insert_foreign_element(parser, token, GUMBO_NAMESPACE_SVG);
     if (token->v.start_tag.is_self_closing) {
       pop_current_node(parser);
@@ -2881,7 +3045,8 @@ 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) })) {
+  } else if (tag_in(token, kStartTag, (gumbo_tagset) { TAG(STYLE), TAG(SCRIPT), TAG(TEMPLATE) }) ||
+             (tag_is(token, kEndTag, GUMBO_TAG_TEMPLATE))) {
     return handle_in_head(parser, token);
   } else if (tag_is(token, kStartTag, GUMBO_TAG_INPUT) &&
              attribute_matches(&token->v.start_tag.attributes,
@@ -2892,7 +3057,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) {
+    if (state->_form_element || has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
       ignore_token(parser);
       return false;
     }
@@ -2900,11 +3065,7 @@ static bool handle_in_table(GumboParser* parser, GumboToken* token) {
     pop_current_node(parser);
     return false;
   } else if (token->type == GUMBO_TOKEN_EOF) {
-    if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_HTML)) {
-      parser_add_parse_error(parser, token);
-      return false;
-    }
-    return true;
+    return handle_in_body(parser, token);
   } else {
     parser_add_parse_error(parser, token);
     state->_foster_parent_insertions = true;
@@ -2949,35 +3110,37 @@ 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_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 (tag_is(token, kEndTag, GUMBO_TAG_CAPTION)) {
     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;
     }
-    if (!tag_is(token, kEndTag, GUMBO_TAG_CAPTION)) {
-      parser_add_parse_error(parser, token);
-      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)) {
+  } 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)) {
       parser_add_parse_error(parser, token);
-      while (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_CAPTION)) {
-        pop_current_node(parser);
-      }
-      result = false;
+      ignore_token(parser);
+      return false;
     }
-    pop_current_node(parser);  // The <caption> itself.
+    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, kEndTag, (gumbo_tagset) { TAG(BODY), TAG(COL),
-          TAG(COLGROUP), TAG(HTML), TAG(TBODY), TAG(TD), TAG(TFOOT), 
-          TAG(TH), TAG(THEAD), TAG(TR) })) {
+    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) } )) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     return false;
@@ -3005,24 +3168,33 @@ 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 (token->type == GUMBO_TOKEN_EOF &&
-             get_current_node(parser) == parser->_output->root) {
-    return true;
+  } 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 (get_current_node(parser) == parser->_output->root) {
+    if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_COLGROUP)) {
       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);
-    if (!tag_is(token, kEndTag, GUMBO_TAG_COLGROUP)) {
-      parser->_parser_state->_reprocess_current_token = true;
-    }
+    parser->_parser_state->_reprocess_current_token = true;
     return true;
   }
 }
@@ -3085,42 +3257,48 @@ 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_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));
-      }
+  } 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;
     }
-    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)) {
+  } 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)) {
+      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;
     }
-    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 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);
+      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;
   } else {
     return handle_in_table(parser, token);
   }
@@ -3132,6 +3310,7 @@ 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);
@@ -3247,14 +3426,11 @@ static bool handle_in_select(GumboParser* parser, GumboToken* token) {
       parser->_parser_state->_reprocess_current_token = true;
     }
     return false;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_SCRIPT)) {
+  } else if (tag_in(token, kStartTag, (gumbo_tagset) { TAG(SCRIPT) , TAG(TEMPLATE) }) ||
+             tag_is(token, kEndTag, GUMBO_TAG_TEMPLATE)) {
     return handle_in_head(parser, token);
   } else if (token->type == GUMBO_TOKEN_EOF) {
-    if (get_current_node(parser) != parser->_output->root) {
-      parser_add_parse_error(parser, token);
-      return false;
-    }
-    return true;
+    return handle_in_body(parser, token);
   } else {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
@@ -3273,14 +3449,16 @@ 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)) {
+    if (!has_an_element_in_table_scope(parser, token->v.end_tag)) {
+      ignore_token(parser);
+      return false;
+    } else {
       close_current_select(parser);
-      reset_insertion_mode_appropriately(parser);
+      // close_current_select already does the reset_insertion_mode_appropriately
+      // reset_insertion_mode_appropriately(parser);
       parser->_parser_state->_reprocess_current_token = true;
-    } else {
-      ignore_token(parser);
+      return false;
     }
-    return false;
   } else {
     return handle_in_select(parser, token);
   }
@@ -3288,8 +3466,80 @@ 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) {
-  // TODO(jdtang): Implement this.
-  return true;
+  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));
+
+#if 0
+
+    // I can not see anywhere in the spec where you do not pop off foreign namespace elements
+
+    for (GumboNode* popped = pop_current_node(parser);
+         popped->v.element.tag_namespace != GUMBO_NAMESPACE_HTML ||
+           !node_html_tag_is(popped, GUMBO_TAG_TEMPLATE);
+         popped = pop_current_node(parser));
+
+#endif
+
+    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;
+  }
 }
 
 // http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#parsing-main-afterbody
@@ -3307,7 +3557,12 @@ static bool handle_after_body(GumboParser* parser, GumboToken* token) {
     ignore_token(parser);
     return false;
   } else if (tag_is(token, kEndTag, GUMBO_TAG_HTML)) {
-    // TODO(jdtang): Handle fragment parsing algorithm case.
+    /* fragment case: ignore the closing HTML token */
+    if (is_fragment_parser(parser)) {
+      parser_add_parse_error(parser, token);
+      ignore_token(parser);
+      return false;
+    }
     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));
@@ -3348,9 +3603,8 @@ static bool handle_in_frameset(GumboParser* parser, GumboToken* token) {
       return false;
     }
     pop_current_node(parser);
-    // 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)) {
+    if (!is_fragment_parser(parser) &&
+        !node_html_tag_is(get_current_node(parser), GUMBO_TAG_FRAMESET)) {
       set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_FRAMESET);
     }
     return true;
@@ -3485,13 +3739,13 @@ static bool handle_in_foreign_content(GumboParser* parser, GumboToken* token) {
   switch (token->type) {
     case GUMBO_TOKEN_NULL:
       parser_add_parse_error(parser, token);
-      token->type = GUMBO_TOKEN_CHARACTER;
       token->v.character = kUtf8ReplacementChar;
       insert_text_token(parser, token);
       return false;
     case GUMBO_TOKEN_WHITESPACE:
       insert_text_token(parser, token);
       return true;
+    case GUMBO_TOKEN_CDATA:
     case GUMBO_TOKEN_CHARACTER:
       insert_text_token(parser, token);
       set_frameset_not_ok(parser);
@@ -3524,27 +3778,41 @@ 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);
-    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) {
+
+    /*
+     * 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) {
     const GumboNamespaceEnum current_namespace =
-        get_current_node(parser)->v.element.tag_namespace;
+        get_adjusted_current_node(parser)->v.element.tag_namespace;
     if (current_namespace == GUMBO_NAMESPACE_MATHML) {
-      adjust_mathml_attributes(parser, token);
+      adjust_mathml_attributes(token);
     }
     if (current_namespace == GUMBO_NAMESPACE_SVG) {
       // Tag adjustment is left to the gumbo_normalize_svg_tagname helper
       // function.
-      adjust_svg_attributes(parser, token);
+      adjust_svg_attributes(token);
     }
-    adjust_foreign_attributes(parser, token);
+    adjust_foreign_attributes(token);
     insert_foreign_element(parser, token, current_namespace);
     if (token->v.start_tag.is_self_closing) {
       pop_current_node(parser);
@@ -3624,8 +3892,10 @@ static bool handle_token(GumboParser* parser, GumboToken* token) {
     parser->_parser_state->_closed_html_tag = true;
   }
 
-  const GumboNode* current_node = get_current_node(parser);
-  assert(!current_node || current_node->type == GUMBO_NODE_ELEMENT);
+  const GumboNode* current_node = get_adjusted_current_node(parser);
+  assert(!current_node ||
+         current_node->type == GUMBO_NODE_ELEMENT ||
+         current_node->type == GUMBO_NODE_TEMPLATE);
   if (current_node) {
     gumbo_debug("Current node: <%s>.\n",
                 gumbo_normalized_tagname(current_node->v.element.tag));
@@ -3653,6 +3923,59 @@ static bool handle_token(GumboParser* parser, GumboToken* token) {
   }
 }
 
+static void fragment_parser_init(GumboParser *parser, GumboTag fragment_ctx) {
+  GumboNode *root;
+
+  assert(fragment_ctx != GUMBO_TAG_LAST);
+
+  // 3
+  parser->_parser_state->_fragment_ctx = create_element(parser, fragment_ctx);
+
+  // 4
+  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));
@@ -3660,12 +3983,21 @@ 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);
+}
+
+GumboOutput* gumbo_parse_fragment(
+    const GumboOptions* options, const char* buffer, size_t length,
+    const GumboTag fragment_ctx) {
   GumboParser parser;
   parser._options = options;
   output_init(&parser);
   gumbo_tokenizer_state_init(&parser, buffer, length);
   parser_state_init(&parser);
 
+  if (fragment_ctx != GUMBO_TAG_LAST)
+    fragment_parser_init(&parser, fragment_ctx);
+
   GumboParserState* state = parser._parser_state;
   gumbo_debug("Parsing %.*s.\n", length, buffer);
 
@@ -3738,13 +4070,13 @@ GumboOutput* gumbo_parse_with_options(
   // empty strings.
   GumboDocument* doc_type = &parser._output->document->v.document;
   if (doc_type->name == NULL) {
-    doc_type->name = gumbo_copy_stringz(&parser, "");
+    doc_type->name = gumbo_strdup("");
   }
   if (doc_type->public_identifier == NULL) {
-    doc_type->public_identifier = gumbo_copy_stringz(&parser, "");
+    doc_type->public_identifier = gumbo_strdup("");
   }
   if (doc_type->system_identifier == NULL) {
-    doc_type->system_identifier = gumbo_copy_stringz(&parser, "");
+    doc_type->system_identifier = gumbo_strdup("");
   }
 
   parser_state_destroy(&parser);
@@ -3752,23 +4084,11 @@ GumboOutput* gumbo_parse_with_options(
   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._options = options;
-  destroy_node(&parser, output->document);
+void gumbo_destroy_output(GumboOutput* output) {
+  gumbo_destroy_node(output->document);
   for (int i = 0; i < output->errors.length; ++i) {
-    gumbo_error_destroy(&parser, output->errors.data[i]);
+    gumbo_error_destroy(output->errors.data[i]);
   }
-  gumbo_vector_destroy(&parser, &output->errors);
-  gumbo_parser_deallocate(&parser, output);
+  gumbo_vector_destroy(&output->errors);
+  gumbo_free(output);
 }
diff --git a/src/string_buffer.c b/src/string_buffer.c
index f7d9712f..f7b94b25 100644
--- a/src/string_buffer.c
+++ b/src/string_buffer.c
@@ -20,46 +20,36 @@
 #include <stdlib.h>
 #include <string.h>
 #include <strings.h>
+#include <stdarg.h>
 
 #include "string_piece.h"
 #include "util.h"
 
-struct GumboInternalParser;
-
 static const size_t kDefaultStringBufferSize = 10;
 
-static void maybe_resize_string_buffer(
-    struct GumboInternalParser* parser, size_t additional_chars,
-    GumboStringBuffer* buffer) {
+static void maybe_resize_string_buffer(size_t additional_chars, GumboStringBuffer* buffer) {
   size_t new_length = buffer->length + additional_chars;
   size_t new_capacity = buffer->capacity;
   while (new_capacity < new_length) {
     new_capacity *= 2;
   }
   if (new_capacity != buffer->capacity) {
-    char* new_data = gumbo_parser_allocate(parser, new_capacity);
-    memcpy(new_data, buffer->data, buffer->length);
-    gumbo_parser_deallocate(parser, buffer->data);
-    buffer->data = new_data;
     buffer->capacity = new_capacity;
+    buffer->data = gumbo_realloc(buffer->data, buffer->capacity);
   }
 }
 
-void gumbo_string_buffer_init(
-    struct GumboInternalParser* parser, GumboStringBuffer* output) {
-  output->data = gumbo_parser_allocate(parser, kDefaultStringBufferSize);
+void gumbo_string_buffer_init(GumboStringBuffer* output) {
+  output->data = gumbo_malloc(kDefaultStringBufferSize);
   output->length = 0;
   output->capacity = kDefaultStringBufferSize;
 }
 
-void gumbo_string_buffer_reserve(
-    struct GumboInternalParser* parser, size_t min_capacity,
-    GumboStringBuffer* output) {
-  maybe_resize_string_buffer(parser, min_capacity - output->length, output);
+void gumbo_string_buffer_reserve(size_t min_capacity, GumboStringBuffer* output) {
+  maybe_resize_string_buffer(min_capacity - output->length, output);
 }
 
-void gumbo_string_buffer_append_codepoint(
-    struct GumboInternalParser* parser, int c, GumboStringBuffer* output) {
+void gumbo_string_buffer_append_codepoint(int c, GumboStringBuffer* output) {
   // num_bytes is actually the number of continuation bytes, 1 less than the
   // total number of bytes.  This is done to keep the loop below simple and
   // should probably change if we unroll it.
@@ -77,30 +67,64 @@ void gumbo_string_buffer_append_codepoint(
     num_bytes = 3;
     prefix = 0xf0;
   }
-  maybe_resize_string_buffer(parser, num_bytes + 1, output);
+  maybe_resize_string_buffer(num_bytes + 1, output);
   output->data[output->length++] = prefix | (c >> (num_bytes * 6));
   for (int i = num_bytes - 1; i >= 0; --i) {
     output->data[output->length++] = 0x80 | (0x3f & (c >> (i * 6)));
   }
 }
 
-void gumbo_string_buffer_append_string(
-    struct GumboInternalParser* parser, GumboStringPiece* str,
+void gumbo_string_buffer_put(GumboStringBuffer *buffer,
+  const char *data, size_t length)
+{
+  maybe_resize_string_buffer(length, buffer);
+  memcpy(buffer->data + buffer->length, data, length);
+  buffer->length += length;
+}
+
+void gumbo_string_buffer_putv(GumboStringBuffer *buffer, int count, ...)
+{
+  va_list ap;
+  int i;
+  size_t total_len = 0;
+
+  va_start(ap, count);
+  for (i = 0; i < count; ++i)
+    total_len += strlen(va_arg(ap, const char *));
+  va_end(ap);
+
+  maybe_resize_string_buffer(total_len, buffer);
+
+  va_start(ap, count);
+  for (i = 0; i < count; ++i) {
+    const char *data = va_arg(ap, const char *);
+    size_t length = strlen(data);
+
+    memcpy(buffer->data + buffer->length, data, length);
+    buffer->length += length;
+  }
+  va_end(ap);
+}
+
+void gumbo_string_buffer_append_string(GumboStringPiece* str,
     GumboStringBuffer* output) {
-  maybe_resize_string_buffer(parser, str->length, output);
-  memcpy(output->data + output->length, str->data, str->length);
-  output->length += str->length;
+  gumbo_string_buffer_put(output, str->data, str->length);
+}
+
+const char* gumbo_string_buffer_cstr(GumboStringBuffer *buffer) {
+  maybe_resize_string_buffer(1, buffer);
+  /* do not increase length of the string */
+  buffer->data[buffer->length] = 0;
+  return buffer->data;
 }
 
-char* gumbo_string_buffer_to_string(
-    struct GumboInternalParser* parser, GumboStringBuffer* input) {
-  char* buffer = gumbo_parser_allocate(parser, input->length + 1);
+char* gumbo_string_buffer_to_string(GumboStringBuffer* input) {
+  char* buffer = gumbo_malloc(input->length + 1);
   memcpy(buffer, input->data, input->length);
   buffer[input->length] = '\0';
   return buffer;
 }
 
-void gumbo_string_buffer_destroy(
-    struct GumboInternalParser* parser, GumboStringBuffer* buffer) {
-  gumbo_parser_deallocate(parser, buffer->data);
+void gumbo_string_buffer_destroy(GumboStringBuffer* buffer) {
+  gumbo_free(buffer->data);
 }
diff --git a/src/string_buffer.h b/src/string_buffer.h
index 4ddff8a9..b52f1ea9 100644
--- a/src/string_buffer.h
+++ b/src/string_buffer.h
@@ -19,6 +19,7 @@
 
 #include <stdbool.h>
 #include <stddef.h>
+#include <string.h>
 
 #include "gumbo.h"
 
@@ -26,8 +27,6 @@
 extern "C" {
 #endif
 
-struct GumboInternalParser;
-
 // A struct representing a mutable, growable string.  This consists of a
 // heap-allocated buffer that may grow (by doubling) as necessary.  When
 // converting to a string, this allocates a new buffer that is only as long as
@@ -45,34 +44,38 @@ typedef struct {
 } GumboStringBuffer;
 
 // Initializes a new GumboStringBuffer.
-void gumbo_string_buffer_init(
-    struct GumboInternalParser* parser, GumboStringBuffer* output);
+void gumbo_string_buffer_init(GumboStringBuffer* output);
 
 // Ensures that the buffer contains at least a certain amount of space.  Most
 // useful with snprintf and the other length-delimited string functions, which
 // may want to write directly into the buffer.
-void gumbo_string_buffer_reserve(
-    struct GumboInternalParser* parser, size_t min_capacity,
-    GumboStringBuffer* output);
+void gumbo_string_buffer_reserve(size_t min_capacity, GumboStringBuffer* output);
 
 // Appends a single Unicode codepoint onto the end of the GumboStringBuffer.
 // This is essentially a UTF-8 encoder, and may add 1-4 bytes depending on the
 // value of the codepoint.
-void gumbo_string_buffer_append_codepoint(
-    struct GumboInternalParser* parser, int c, GumboStringBuffer* output);
+void gumbo_string_buffer_append_codepoint(int c, GumboStringBuffer* output);
 
 // Appends a string onto the end of the GumboStringBuffer.
-void gumbo_string_buffer_append_string(
-    struct GumboInternalParser* parser, GumboStringPiece* str,
-    GumboStringBuffer* output);
+void gumbo_string_buffer_append_string(GumboStringPiece* str, GumboStringBuffer* output);
 
 // Converts this string buffer to const char*, alloctaing a new buffer for it.
-char* gumbo_string_buffer_to_string(
-    struct GumboInternalParser* parser, GumboStringBuffer* input);
+char* gumbo_string_buffer_to_string(GumboStringBuffer* input);
 
 // Deallocates this GumboStringBuffer.
-void gumbo_string_buffer_destroy(
-    struct GumboInternalParser* parser, GumboStringBuffer* buffer);
+void gumbo_string_buffer_destroy(GumboStringBuffer* buffer);
+
+const char* gumbo_string_buffer_cstr(GumboStringBuffer *buffer);
+void gumbo_string_buffer_put(GumboStringBuffer *buffer,
+    const char *data, size_t length);
+
+static inline void gumbo_string_buffer_puts(GumboStringBuffer *buffer,
+    const char *data)
+{
+	gumbo_string_buffer_put(buffer, data, strlen(data));
+}
+
+void gumbo_string_buffer_putv(GumboStringBuffer *out, int n, ...);
 
 #ifdef __cplusplus
 }
diff --git a/src/string_piece.c b/src/string_piece.c
index 98654c91..b6a9ff30 100644
--- a/src/string_piece.c
+++ b/src/string_piece.c
@@ -39,11 +39,9 @@ bool gumbo_string_equals_ignore_case(
       !strncasecmp(str1->data, str2->data, str1->length);
 }
 
-void gumbo_string_copy(
-    struct GumboInternalParser* parser, GumboStringPiece* dest,
-    const GumboStringPiece* source) {
+void gumbo_string_copy(GumboStringPiece* dest, const GumboStringPiece* source) {
   dest->length = source->length;
-  char* buffer = gumbo_parser_allocate(parser, source->length);
+  char* buffer = gumbo_malloc(source->length);
   memcpy(buffer, source->data, source->length);
   dest->data = buffer;
 }
diff --git a/src/string_piece.h b/src/string_piece.h
index 57be1607..ebf19866 100644
--- a/src/string_piece.h
+++ b/src/string_piece.h
@@ -28,9 +28,7 @@ struct GumboInternalParser;
 // Performs a deep-copy of an GumboStringPiece, allocating a fresh buffer in the
 // destination and copying over the characters from source.  Dest should be
 // empty, with no buffer allocated; otherwise, this leaks it.
-void gumbo_string_copy(
-    struct GumboInternalParser* parser, GumboStringPiece* dest,
-    const GumboStringPiece* source);
+void gumbo_string_copy(GumboStringPiece* dest, const GumboStringPiece* source);
 
 #ifdef __cplusplus
 }
diff --git a/src/tag.c b/src/tag.c
index 7b745d6a..7b4030c8 100644
--- a/src/tag.c
+++ b/src/tag.c
@@ -15,165 +15,15 @@
 // Author: jdtang@google.com (Jonathan Tang)
 
 #include "gumbo.h"
+#include "util.h"
 
 #include <assert.h>
 #include <ctype.h>
 #include <strings.h>    // For strcasecmp.
+#include <string.h>    // For strcasecmp.
 
-// NOTE(jdtang): Keep this in sync with the GumboTag enum in the header.
-// TODO(jdtang): Investigate whether there're efficiency benefits to putting the
-// most common tag names first, or to putting them in alphabetical order and
-// using a binary search.
 const char* kGumboTagNames[] = {
-  "html",
-  "head",
-  "title",
-  "base",
-  "link",
-  "meta",
-  "style",
-  "script",
-  "noscript",
-  "template",
-  "body",
-  "article",
-  "section",
-  "nav",
-  "aside",
-  "h1",
-  "h2",
-  "h3",
-  "h4",
-  "h5",
-  "h6",
-  "hgroup",
-  "header",
-  "footer",
-  "address",
-  "p",
-  "hr",
-  "pre",
-  "blockquote",
-  "ol",
-  "ul",
-  "li",
-  "dl",
-  "dt",
-  "dd",
-  "figure",
-  "figcaption",
-  "main",
-  "div",
-  "a",
-  "em",
-  "strong",
-  "small",
-  "s",
-  "cite",
-  "q",
-  "dfn",
-  "abbr",
-  "data",
-  "time",
-  "code",
-  "var",
-  "samp",
-  "kbd",
-  "sub",
-  "sup",
-  "i",
-  "b",
-  "u",
-  "mark",
-  "ruby",
-  "rt",
-  "rp",
-  "bdi",
-  "bdo",
-  "span",
-  "br",
-  "wbr",
-  "ins",
-  "del",
-  "image",
-  "img",
-  "iframe",
-  "embed",
-  "object",
-  "param",
-  "video",
-  "audio",
-  "source",
-  "track",
-  "canvas",
-  "map",
-  "area",
-  "math",
-  "mi",
-  "mo",
-  "mn",
-  "ms",
-  "mtext",
-  "mglyph",
-  "malignmark",
-  "annotation-xml",
-  "svg",
-  "foreignobject",
-  "desc",
-  "table",
-  "caption",
-  "colgroup",
-  "col",
-  "tbody",
-  "thead",
-  "tfoot",
-  "tr",
-  "td",
-  "th",
-  "form",
-  "fieldset",
-  "legend",
-  "label",
-  "input",
-  "button",
-  "select",
-  "datalist",
-  "optgroup",
-  "option",
-  "textarea",
-  "keygen",
-  "output",
-  "progress",
-  "meter",
-  "details",
-  "summary",
-  "menu",
-  "menuitem",
-  "applet",
-  "acronym",
-  "bgsound",
-  "dir",
-  "frame",
-  "frameset",
-  "noframes",
-  "isindex",
-  "listing",
-  "xmp",
-  "nextid",
-  "noembed",
-  "plaintext",
-  "rb",
-  "strike",
-  "basefont",
-  "big",
-  "blink",
-  "center",
-  "font",
-  "marquee",
-  "multicol",
-  "nobr",
-  "spacer",
-  "tt",
+# include "tag_strings.h"
   "",                   // TAG_UNKNOWN
   "",                   // TAG_LAST
 };
@@ -183,7 +33,6 @@ const char* gumbo_normalized_tagname(GumboTag tag) {
   return kGumboTagNames[tag];
 }
 
-// TODO(jdtang): Add test for this.
 void gumbo_tag_from_original_text(GumboStringPiece* text) {
   if (text->data == NULL) {
     return;
@@ -212,14 +61,34 @@ void gumbo_tag_from_original_text(GumboStringPiece* text) {
   }
 }
 
-GumboTag gumbo_tag_enum(const char* tagname) {
-  for (int i = 0; i < GUMBO_TAG_LAST; ++i) {
-    // TODO(jdtang): strcasecmp is non-portable, so if we want to support
-    // non-GCC compilers, we'll need some #ifdef magic.  This source already has
-    // pretty significant issues with MSVC6 anyway.
-    if (strcasecmp(tagname, kGumboTagNames[i]) == 0) {
-      return i;
-    }
-  }
+/*
+ * Override the `tolower` implementation in the perfect hash
+ * to use ours. We need a custom `tolower` that only does ASCII
+ * characters and is locale-independent to remain truthy to the
+ * standard
+ */
+#define tolower(c) gumbo_tolower(c)
+#include "tag_perf.h"
+
+static int
+case_memcmp(const char *s1, const char *s2, int n)
+{
+	while (n--) {
+		unsigned char c1 = gumbo_tolower(*s1++);
+		unsigned char c2 = gumbo_tolower(*s2++);
+		if (c1 != c2)
+			return (int)c1 - (int)c2;
+	}
+	return 0;
+}
+
+GumboTag gumbo_tagn_enum(const char* tagname, int length) {
+  int position = perfhash((const unsigned char *)tagname, length);
+  if (position >= 0 && !case_memcmp(tagname, kGumboTagNames[position], length))
+    return (GumboTag)position;
   return GUMBO_TAG_UNKNOWN;
 }
+
+GumboTag gumbo_tag_enum(const char* tagname) {
+  return gumbo_tagn_enum(tagname, strlen(tagname));
+}
diff --git a/src/tag.in b/src/tag.in
new file mode 100644
index 00000000..4c252648
--- /dev/null
+++ b/src/tag.in
@@ -0,0 +1,150 @@
+html
+head
+title
+base
+link
+meta
+style
+script
+noscript
+template
+body
+article
+section
+nav
+aside
+h1
+h2
+h3
+h4
+h5
+h6
+hgroup
+header
+footer
+address
+p
+hr
+pre
+blockquote
+ol
+ul
+li
+dl
+dt
+dd
+figure
+figcaption
+main
+div
+a
+em
+strong
+small
+s
+cite
+q
+dfn
+abbr
+data
+time
+code
+var
+samp
+kbd
+sub
+sup
+i
+b
+u
+mark
+ruby
+rt
+rp
+bdi
+bdo
+span
+br
+wbr
+ins
+del
+image
+img
+iframe
+embed
+object
+param
+video
+audio
+source
+track
+canvas
+map
+area
+math
+mi
+mo
+mn
+ms
+mtext
+mglyph
+malignmark
+annotation-xml
+svg
+foreignobject
+desc
+table
+caption
+colgroup
+col
+tbody
+thead
+tfoot
+tr
+td
+th
+form
+fieldset
+legend
+label
+input
+button
+select
+datalist
+optgroup
+option
+textarea
+keygen
+output
+progress
+meter
+details
+summary
+menu
+menuitem
+applet
+acronym
+bgsound
+dir
+frame
+frameset
+noframes
+isindex
+listing
+xmp
+nextid
+noembed
+plaintext
+rb
+strike
+basefont
+big
+blink
+center
+font
+marquee
+multicol
+nobr
+spacer
+tt
+rtc
diff --git a/src/tag_enum.h b/src/tag_enum.h
new file mode 100644
index 00000000..411669ee
--- /dev/null
+++ b/src/tag_enum.h
@@ -0,0 +1,150 @@
+GUMBO_TAG_HTML,
+GUMBO_TAG_HEAD,
+GUMBO_TAG_TITLE,
+GUMBO_TAG_BASE,
+GUMBO_TAG_LINK,
+GUMBO_TAG_META,
+GUMBO_TAG_STYLE,
+GUMBO_TAG_SCRIPT,
+GUMBO_TAG_NOSCRIPT,
+GUMBO_TAG_TEMPLATE,
+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,
+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,
+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,
+GUMBO_TAG_INS,
+GUMBO_TAG_DEL,
+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,
+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,
+GUMBO_TAG_SVG,
+GUMBO_TAG_FOREIGNOBJECT,
+GUMBO_TAG_DESC,
+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,
+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,
+GUMBO_TAG_DETAILS,
+GUMBO_TAG_SUMMARY,
+GUMBO_TAG_MENU,
+GUMBO_TAG_MENUITEM,
+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,
+GUMBO_TAG_RTC,
diff --git a/src/tag_perf.h b/src/tag_perf.h
new file mode 100644
index 00000000..31b560ba
--- /dev/null
+++ b/src/tag_perf.h
@@ -0,0 +1,104 @@
+/*
+ * d=2
+ * n=200
+ * m=150
+ * c=1.33
+ * maxlen=2
+ * minklen=1
+ * maxklen=14
+ * minchar=45
+ * maxchar=121
+ * loop=0
+ * numiter=828
+ * seed=0
+ */
+
+static int g[] = {
+	86, -1, -1, 53, 36, -1, 0, 62, -1, 5,
+	87, 132, 0, -1, 42, 103, 81, 89, 125, 72,
+	8, -1, 34, 70, 46, 132, 13, -1, -1, 145,
+	76, 120, 100, 138, 37, -1, 136, 24, 93, -1,
+	36, 88, 100, 29, -1, 82, 120, -1, 126, 148,
+	149, 43, 87, 95, 83, 138, -1, 6, -1, 104,
+	24, 0, 0, 128, 139, 0, 137, 54, -1, 0,
+	77, 42, 0, -1, 88, 23, 29, 108, 70, 149,
+	-1, 93, 20, -1, 25, 55, 0, 20, 72, 122,
+	-1, -1, 0, 144, 73, 6, 11, 7, 42, 112,
+	92, 94, 80, 50, 66, 23, 8, 74, -1, 56,
+	136, 53, 0, 60, -1, 3, -1, 99, 149, 40,
+	98, 118, 81, 0, 50, 115, -1, -1, 86, 9,
+	21, 26, 1, 0, 117, 9, 36, 91, 35, 41,
+	23, 75, 89, 35, 0, 147, 86, 7, 115, -1,
+	49, 107, 5, 89, 3, 11, -1, 17, 16, -1,
+	29, 35, -1, 95, 110, 96, 43, 42, 121, -1,
+	46, 83, -1, 0, 147, 126, 24, -1, 28, 109,
+	82, 43, 12, 82, -1, -1, -1, 0, 35, 12,
+	86, 92, -1, 146, 96, 58, 93, 143, -1, -1,
+};
+
+static int T0[] = {
+	196, 103, 27, 185, 60, 0, 58, 36, 180, 118,
+	101, 180, 61, 125, 144, 167, 140, 104, 131, 195,
+	176, 62, 79, 175, 195, 103, 116, 194, 122, 73,
+	44, 119, 128, 23, 56, 188, 23, 114, 24, 156,
+	32, 78, 136, 46, 3, 32, 165, 95, 136, 97,
+	90, 65, 111, 121, 40, 106, 25, 108, 53, 99,
+	181, 49, 18, 110, 72, 74, 50, 48, 141, 27,
+	4, 125, 105, 92, 171, 60, 124, 1, 72, 96,
+	178, 59, 58, 61, 0, 185, 12, 176, 111, 121,
+	49, 170, 70, 48, 43, 82, 178, 157, 34, 62,
+	137, 148, 110, 160, 96, 11, 50, 22, 12, 74,
+	71, 143, 133, 129, 4, 86, 67, 168, 62, 130,
+	41, 63, 101, 63, 112, 96, 146, 90, 5, 132,
+	153, 95, 32, 15, 7, 80, 26, 57, 103, 191,
+	83, 126, 134, 169, 55, 90, 55, 74, 58, 69,
+	5, 99, 132, 58,
+};
+
+static int T1[] = {
+	87, 14, 91, 162, 194, 198, 131, 1, 89, 2,
+	154, 17, 98, 25, 7, 121, 145, 178, 28, 70,
+	94, 135, 77, 129, 134, 137, 69, 128, 88, 126,
+	114, 175, 92, 5, 89, 87, 3, 20, 88, 44,
+	174, 194, 14, 73, 171, 21, 194, 117, 151, 175,
+	139, 45, 110, 17, 127, 196, 106, 148, 124, 194,
+	26, 190, 169, 118, 195, 59, 157, 150, 31, 197,
+	147, 6, 143, 161, 79, 67, 134, 68, 163, 61,
+	104, 124, 56, 39, 115, 99, 140, 101, 63, 91,
+	124, 4, 134, 110, 132, 61, 150, 96, 116, 167,
+	80, 174, 115, 169, 14, 184, 24, 47, 4, 188,
+	60, 109, 64, 68, 148, 179, 168, 41, 80, 183,
+	84, 156, 187, 18, 18, 119, 79, 169, 168, 148,
+	88, 0, 122, 3, 169, 88, 139, 146, 88, 144,
+	86, 148, 5, 150, 17, 105, 81, 137, 98, 113,
+	120, 182, 69, 107,
+};
+
+static int
+perfhash(const unsigned char *key, int len)
+{
+	int i;
+	int n;
+	unsigned f0, f1;
+	const unsigned char *kp = key;
+
+	if (len < 1 || len > 14)
+		return -1;
+
+	for (i=-45, n=0, f0=f1=0; n < len; ++n) {
+		int c = kp[n];
+		c = tolower(c);
+		if (c < 45 || c > 121)
+			return -1;
+		f0 += T0[i + c];
+		f1 += T1[i + c];
+		i += 77;
+		if (i >= 109)
+			i = -45;
+	}
+
+	f0 %= 200;
+	f1 %= 200;
+
+	return (g[f0] + g[f1]) % 150;
+}
diff --git a/src/tag_strings.h b/src/tag_strings.h
new file mode 100644
index 00000000..2db0bac9
--- /dev/null
+++ b/src/tag_strings.h
@@ -0,0 +1,150 @@
+"html",
+"head",
+"title",
+"base",
+"link",
+"meta",
+"style",
+"script",
+"noscript",
+"template",
+"body",
+"article",
+"section",
+"nav",
+"aside",
+"h1",
+"h2",
+"h3",
+"h4",
+"h5",
+"h6",
+"hgroup",
+"header",
+"footer",
+"address",
+"p",
+"hr",
+"pre",
+"blockquote",
+"ol",
+"ul",
+"li",
+"dl",
+"dt",
+"dd",
+"figure",
+"figcaption",
+"main",
+"div",
+"a",
+"em",
+"strong",
+"small",
+"s",
+"cite",
+"q",
+"dfn",
+"abbr",
+"data",
+"time",
+"code",
+"var",
+"samp",
+"kbd",
+"sub",
+"sup",
+"i",
+"b",
+"u",
+"mark",
+"ruby",
+"rt",
+"rp",
+"bdi",
+"bdo",
+"span",
+"br",
+"wbr",
+"ins",
+"del",
+"image",
+"img",
+"iframe",
+"embed",
+"object",
+"param",
+"video",
+"audio",
+"source",
+"track",
+"canvas",
+"map",
+"area",
+"math",
+"mi",
+"mo",
+"mn",
+"ms",
+"mtext",
+"mglyph",
+"malignmark",
+"annotation-xml",
+"svg",
+"foreignobject",
+"desc",
+"table",
+"caption",
+"colgroup",
+"col",
+"tbody",
+"thead",
+"tfoot",
+"tr",
+"td",
+"th",
+"form",
+"fieldset",
+"legend",
+"label",
+"input",
+"button",
+"select",
+"datalist",
+"optgroup",
+"option",
+"textarea",
+"keygen",
+"output",
+"progress",
+"meter",
+"details",
+"summary",
+"menu",
+"menuitem",
+"applet",
+"acronym",
+"bgsound",
+"dir",
+"frame",
+"frameset",
+"noframes",
+"isindex",
+"listing",
+"xmp",
+"nextid",
+"noembed",
+"plaintext",
+"rb",
+"strike",
+"basefont",
+"big",
+"blink",
+"center",
+"font",
+"marquee",
+"multicol",
+"nobr",
+"spacer",
+"tt",
+"rtc",
diff --git a/src/token_type.h b/src/token_type.h
index 5874d1a2..eeab5078 100644
--- a/src/token_type.h
+++ b/src/token_type.h
@@ -29,6 +29,7 @@ typedef enum {
   GUMBO_TOKEN_COMMENT,
   GUMBO_TOKEN_WHITESPACE,
   GUMBO_TOKEN_CHARACTER,
+  GUMBO_TOKEN_CDATA,
   GUMBO_TOKEN_NULL,
   GUMBO_TOKEN_EOF
 } GumboTokenType;
diff --git a/src/tokenizer.c b/src/tokenizer.c
index 9dde62cd..c43b5d8b 100644
--- a/src/tokenizer.c
+++ b/src/tokenizer.c
@@ -136,6 +136,10 @@ typedef struct GumboInternalTokenizerState {
   // markup declaration state.
   bool _is_current_node_foreign;
 
+  // A flag indicating whether the tokenizer is in a CDATA section.  If so, then
+  // text tokens emitted will be GUMBO_TOKEN_CDATA.
+  bool _is_in_cdata;
+
   // Certain states (notably character references) may emit two character tokens
   // at once, but the contract for lex() fills in only one token at a time.  The
   // extra character is buffered here, and then this is checked on entry to
@@ -304,18 +308,11 @@ static void tokenizer_add_parse_error(GumboParser* parser, GumboErrorType type)
   }
 }
 
-static bool is_alpha(int c) {
-  // We don't use ISO C isupper/islower functions here because they
-  // depend upon the program's locale, while the behavior of the HTML5 spec is
-  // independent of which locale the program is run in.
-  return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
-}
-
-static int ensure_lowercase(int c) {
-  return c >= 'A' && c <= 'Z' ? c + 0x20 : c;
-}
+static GumboTokenType get_char_token_type(bool is_in_cdata, int c) {
+  if (is_in_cdata && c > 0) {
+    return GUMBO_TOKEN_CDATA;
+  }
 
-static GumboTokenType get_char_token_type(int c) {
   switch (c) {
     case '\t':
     case '\n':
@@ -348,19 +345,19 @@ static void clear_temporary_buffer(GumboParser* parser) {
   GumboTokenizerState* tokenizer = parser->_tokenizer_state;
   assert(!tokenizer->_temporary_buffer_emit);
   utf8iterator_mark(&tokenizer->_input);
-  gumbo_string_buffer_destroy(parser, &tokenizer->_temporary_buffer);
-  gumbo_string_buffer_init(parser, &tokenizer->_temporary_buffer);
+  gumbo_string_buffer_destroy(&tokenizer->_temporary_buffer);
+  gumbo_string_buffer_init(&tokenizer->_temporary_buffer);
   // The temporary buffer and script data buffer are the same object in the
   // spec, so the script data buffer should be cleared as well.
-  gumbo_string_buffer_destroy(parser, &tokenizer->_script_data_buffer);
-  gumbo_string_buffer_init(parser, &tokenizer->_script_data_buffer);
+  gumbo_string_buffer_destroy(&tokenizer->_script_data_buffer);
+  gumbo_string_buffer_init(&tokenizer->_script_data_buffer);
 }
 
 // Appends a codepoint to the temporary buffer.
 static void append_char_to_temporary_buffer(
     GumboParser* parser, int codepoint) {
   gumbo_string_buffer_append_codepoint(
-      parser, codepoint, &parser->_tokenizer_state->_temporary_buffer);
+      codepoint, &parser->_tokenizer_state->_temporary_buffer);
 }
 
 // Checks to see if the temporary buffer equals a certain string.
@@ -419,7 +416,7 @@ static void reset_tag_buffer_start_point(GumboParser* parser) {
 static void finish_temporary_buffer(GumboParser* parser, const char** output) {
   GumboTokenizerState* tokenizer = parser->_tokenizer_state;
   *output =
-      gumbo_string_buffer_to_string(parser, &tokenizer->_temporary_buffer);
+      gumbo_string_buffer_to_string(&tokenizer->_temporary_buffer);
   clear_temporary_buffer(parser);
 }
 
@@ -458,7 +455,7 @@ static void finish_token(GumboParser* parser, GumboToken* token) {
 static void finish_doctype_public_id(GumboParser* parser) {
   GumboTokenDocType* doc_type_state =
       &parser->_tokenizer_state->_doc_type_state;
-  gumbo_parser_deallocate(parser, (void*) doc_type_state->public_identifier);
+  gumbo_free((void*) doc_type_state->public_identifier);
   finish_temporary_buffer(parser, &doc_type_state->public_identifier);
   doc_type_state->has_public_identifier = true;
 }
@@ -468,14 +465,14 @@ static void finish_doctype_public_id(GumboParser* parser) {
 static void finish_doctype_system_id(GumboParser* parser) {
   GumboTokenDocType* doc_type_state =
       &parser->_tokenizer_state->_doc_type_state;
-  gumbo_parser_deallocate(parser, (void*) doc_type_state->system_identifier);
+  gumbo_free((void*) doc_type_state->system_identifier);
   finish_temporary_buffer(parser, &doc_type_state->system_identifier);
   doc_type_state->has_system_identifier = true;
 }
 
 // Writes a single specified character to the output token.
 static void emit_char(GumboParser* parser, int c, GumboToken* output) {
-  output->type = get_char_token_type(c);
+  output->type = get_char_token_type(parser->_tokenizer_state->_is_in_cdata, c);
   output->v.character = c;
   finish_token(parser, output);
 }
@@ -541,14 +538,14 @@ static StateResult emit_current_tag(GumboParser* parser, GumboToken* output) {
     // deallocated.  There may also be attributes to destroy, in certain broken
     // cases like </div</th> (the "th" is an attribute there).
     for (int i = 0; i < tag_state->_attributes.length; ++i) {
-      gumbo_destroy_attribute(parser, tag_state->_attributes.data[i]);
+      gumbo_destroy_attribute(tag_state->_attributes.data[i]);
     }
-    gumbo_parser_deallocate(parser, tag_state->_attributes.data);
+    gumbo_free(tag_state->_attributes.data);
     mark_tag_state_as_empty(tag_state);
     gumbo_debug("Emitted end tag %s.\n",
                gumbo_normalized_tagname(tag_state->_tag));
   }
-  gumbo_string_buffer_destroy(parser, &tag_state->_buffer);
+  gumbo_string_buffer_destroy(&tag_state->_buffer);
   finish_token(parser, output);
   gumbo_debug("Original text = %.*s.\n", output->original_text.length, output->original_text.data);
   assert(output->original_text.length >= 2);
@@ -564,11 +561,11 @@ static StateResult emit_current_tag(GumboParser* parser, GumboToken* output) {
 static void abandon_current_tag(GumboParser* parser) {
   GumboTagState* tag_state = &parser->_tokenizer_state->_tag_state;
   for (int i = 0; i < tag_state->_attributes.length; ++i) {
-    gumbo_destroy_attribute(parser, tag_state->_attributes.data[i]);
+    gumbo_destroy_attribute(tag_state->_attributes.data[i]);
   }
-  gumbo_parser_deallocate(parser, tag_state->_attributes.data);
+  gumbo_free(tag_state->_attributes.data);
   mark_tag_state_as_empty(tag_state);
-  gumbo_string_buffer_destroy(parser, &tag_state->_buffer);
+  gumbo_string_buffer_destroy(&tag_state->_buffer);
   gumbo_debug("Abandoning current tag.\n");
 }
 
@@ -661,7 +658,7 @@ static void append_char_to_tag_buffer(GumboParser* parser, int codepoint,
   if (buffer->length == 0 && reinitilize_position_on_first) {
     reset_tag_buffer_start_point(parser);
   }
-  gumbo_string_buffer_append_codepoint(parser, codepoint, buffer);
+  gumbo_string_buffer_append_codepoint(codepoint, buffer);
 }
 
 // (Re-)initialize the tag buffer.  This also resets the original_text pointer
@@ -670,7 +667,7 @@ static void initialize_tag_buffer(GumboParser* parser) {
   GumboTokenizerState* tokenizer = parser->_tokenizer_state;
   GumboTagState* tag_state = &tokenizer->_tag_state;
 
-  gumbo_string_buffer_init(parser, &tag_state->_buffer);
+  gumbo_string_buffer_init(&tag_state->_buffer);
   reset_tag_buffer_start_point(parser);
 }
 
@@ -681,15 +678,15 @@ static void start_new_tag(GumboParser* parser, bool is_start_tag) {
   GumboTokenizerState* tokenizer = parser->_tokenizer_state;
   GumboTagState* tag_state = &tokenizer->_tag_state;
   int c = utf8iterator_current(&tokenizer->_input);
-  assert(is_alpha(c));
-  c = ensure_lowercase(c);
-  assert(is_alpha(c));
+  assert(gumbo_isalpha(c));
+  c = gumbo_tolower(c);
+  assert(gumbo_isalpha(c));
 
   initialize_tag_buffer(parser);
-  gumbo_string_buffer_append_codepoint(parser, c, &tag_state->_buffer);
+  gumbo_string_buffer_append_codepoint(c, &tag_state->_buffer);
 
   assert(tag_state->_attributes.data == NULL);
-  gumbo_vector_init(parser, 4, &tag_state->_attributes);
+  gumbo_vector_init(4, &tag_state->_attributes);
   tag_state->_drop_next_attr_value = false;
   tag_state->_is_start_tag = is_start_tag;
   tag_state->_is_self_closing = false;
@@ -700,7 +697,7 @@ static void start_new_tag(GumboParser* parser, bool is_start_tag) {
 static void copy_over_tag_buffer(GumboParser* parser, const char** output) {
   GumboTokenizerState* tokenizer = parser->_tokenizer_state;
   GumboTagState* tag_state = &tokenizer->_tag_state;
-  *output = gumbo_string_buffer_to_string(parser, &tag_state->_buffer);
+  *output = gumbo_string_buffer_to_string(&tag_state->_buffer);
 }
 
 // Fills in:
@@ -732,8 +729,7 @@ static void copy_over_original_tag_text(
 
 // Releases and then re-initializes the tag buffer.
 static void reinitialize_tag_buffer(GumboParser* parser) {
-  gumbo_parser_deallocate(
-      parser, parser->_tokenizer_state->_tag_state._buffer.data);
+  gumbo_free(parser->_tokenizer_state->_tag_state._buffer.data);
   initialize_tag_buffer(parser);
 }
 
@@ -743,11 +739,9 @@ static void finish_tag_name(GumboParser* parser) {
   GumboTokenizerState* tokenizer = parser->_tokenizer_state;
   GumboTagState* tag_state = &tokenizer->_tag_state;
 
-  const char* temp;
-  copy_over_tag_buffer(parser, &temp);
-  tag_state->_tag = gumbo_tag_enum(temp);
+  tag_state->_tag = gumbo_tagn_enum(
+		tag_state->_buffer.data, tag_state->_buffer.length);
   reinitialize_tag_buffer(parser);
-  gumbo_parser_deallocate(parser, (void*) temp);
 }
 
 // Adds an ERR_DUPLICATE_ATTR parse error to the parser's error struct.
@@ -795,15 +789,15 @@ static bool finish_attribute_name(GumboParser* parser) {
     }
   }
 
-  GumboAttribute* attr = gumbo_parser_allocate(parser, sizeof(GumboAttribute));
+  GumboAttribute* attr = gumbo_malloc(sizeof(GumboAttribute));
   attr->attr_namespace = GUMBO_ATTR_NAMESPACE_NONE;
   copy_over_tag_buffer(parser, &attr->name);
   copy_over_original_tag_text(parser, &attr->original_name,
                               &attr->name_start, &attr->name_end);
-  attr->value = gumbo_copy_stringz(parser, "");
+  attr->value = gumbo_strdup("");
   copy_over_original_tag_text(parser, &attr->original_value,
                               &attr->name_start, &attr->name_end);
-  gumbo_vector_add(parser, attr, attributes);
+  gumbo_vector_add(attr, attributes);
   reinitialize_tag_buffer(parser);
   return true;
 }
@@ -822,7 +816,7 @@ static void finish_attribute_value(GumboParser* parser) {
 
   GumboAttribute* attr =
       tag_state->_attributes.data[tag_state->_attributes.length - 1];
-  gumbo_parser_deallocate(parser, (void*) attr->value);
+  gumbo_free((void*) attr->value);
   copy_over_tag_buffer(parser, &attr->value);
   copy_over_original_tag_text(parser, &attr->original_value,
                               &attr->value_start, &attr->value_end);
@@ -833,32 +827,28 @@ static void finish_attribute_value(GumboParser* parser) {
 static bool is_appropriate_end_tag(GumboParser* parser) {
   GumboTagState* tag_state = &parser->_tokenizer_state->_tag_state;
   assert(!tag_state->_is_start_tag);
-  // Null terminate the current string buffer, so it can be passed to
-  // gumbo_tag_enum, but don't increment the length in case we need to dump the
-  // buffer as character tokens.
-  gumbo_string_buffer_append_codepoint(parser, '\0', &tag_state->_buffer);
-  --tag_state->_buffer.length;
   return tag_state->_last_start_tag != GUMBO_TAG_LAST &&
-      tag_state->_last_start_tag == gumbo_tag_enum(tag_state->_buffer.data);
+      tag_state->_last_start_tag ==
+	  gumbo_tagn_enum(tag_state->_buffer.data, tag_state->_buffer.length);
 }
 
 void gumbo_tokenizer_state_init(
     GumboParser* parser, const char* text, size_t text_length) {
-  GumboTokenizerState* tokenizer =
-      gumbo_parser_allocate(parser, sizeof(GumboTokenizerState));
+  GumboTokenizerState* tokenizer = gumbo_malloc(sizeof(GumboTokenizerState));
   parser->_tokenizer_state = tokenizer;
   gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
   tokenizer->_reconsume_current_input = false;
   tokenizer->_is_current_node_foreign = false;
+  tokenizer->_is_in_cdata = false;
   tokenizer->_tag_state._last_start_tag = GUMBO_TAG_LAST;
 
   tokenizer->_buffered_emit_char = kGumboNoChar;
-  gumbo_string_buffer_init(parser, &tokenizer->_temporary_buffer);
+  gumbo_string_buffer_init(&tokenizer->_temporary_buffer);
   tokenizer->_temporary_buffer_emit = NULL;
 
   mark_tag_state_as_empty(&tokenizer->_tag_state);
 
-  gumbo_string_buffer_init(parser, &tokenizer->_script_data_buffer);
+  gumbo_string_buffer_init(&tokenizer->_script_data_buffer);
   tokenizer->_token_start = text;
   utf8iterator_init(parser, text, text_length, &tokenizer->_input);
   utf8iterator_get_position(&tokenizer->_input, &tokenizer->_token_start_pos);
@@ -870,9 +860,9 @@ void gumbo_tokenizer_state_destroy(GumboParser* parser) {
   assert(tokenizer->_doc_type_state.name == NULL);
   assert(tokenizer->_doc_type_state.public_identifier == NULL);
   assert(tokenizer->_doc_type_state.system_identifier == NULL);
-  gumbo_string_buffer_destroy(parser, &tokenizer->_temporary_buffer);
-  gumbo_string_buffer_destroy(parser, &tokenizer->_script_data_buffer);
-  gumbo_parser_deallocate(parser, tokenizer);
+  gumbo_string_buffer_destroy(&tokenizer->_temporary_buffer);
+  gumbo_string_buffer_destroy(&tokenizer->_script_data_buffer);
+  gumbo_free(tokenizer);
 }
 
 void gumbo_tokenizer_set_state(GumboParser* parser, GumboTokenizerEnum state) {
@@ -1026,7 +1016,7 @@ static StateResult handle_tag_open_state(
       tokenizer_add_parse_error(parser, GUMBO_ERR_TAG_STARTS_WITH_QUESTION);
       return NEXT_CHAR;
     default:
-      if (is_alpha(c)) {
+      if (gumbo_isalpha(c)) {
         gumbo_tokenizer_set_state(parser, GUMBO_LEX_TAG_NAME);
         start_new_tag(parser, true);
         return NEXT_CHAR;
@@ -1054,7 +1044,7 @@ static StateResult handle_end_tag_open_state(
       gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
       return emit_temporary_buffer(parser, output);
     default:
-      if (is_alpha(c)) {
+      if (gumbo_isalpha(c)) {
         gumbo_tokenizer_set_state(parser, GUMBO_LEX_TAG_NAME);
         start_new_tag(parser, false);
       } else {
@@ -1097,7 +1087,7 @@ static StateResult handle_tag_name_state(
       gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
       return NEXT_CHAR;
     default:
-      append_char_to_tag_buffer(parser, ensure_lowercase(c), true);
+      append_char_to_tag_buffer(parser, gumbo_tolower(c), true);
       return NEXT_CHAR;
   }
 }
@@ -1123,7 +1113,7 @@ static StateResult handle_rcdata_end_tag_open_state(
     GumboParser* parser, GumboTokenizerState* tokenizer,
     int c, GumboToken* output) {
   assert(temporary_buffer_equals(parser, "</"));
-  if (is_alpha(c)) {
+  if (gumbo_isalpha(c)) {
     gumbo_tokenizer_set_state(parser, GUMBO_LEX_RCDATA_END_TAG_NAME);
     start_new_tag(parser, false);
     append_char_to_temporary_buffer(parser, c);
@@ -1140,8 +1130,8 @@ static StateResult handle_rcdata_end_tag_name_state(
     GumboParser* parser, GumboTokenizerState* tokenizer,
     int c, GumboToken* output) {
   assert(tokenizer->_temporary_buffer.length >= 2);
-  if (is_alpha(c)) {
-    append_char_to_tag_buffer(parser, ensure_lowercase(c), true);
+  if (gumbo_isalpha(c)) {
+    append_char_to_tag_buffer(parser, gumbo_tolower(c), true);
     append_char_to_temporary_buffer(parser, c);
     return NEXT_CHAR;
   } else if (is_appropriate_end_tag(parser)) {
@@ -1189,7 +1179,7 @@ static StateResult handle_rawtext_end_tag_open_state(
     GumboParser* parser, GumboTokenizerState* tokenizer,
     int c, GumboToken* output) {
   assert(temporary_buffer_equals(parser, "</"));
-  if (is_alpha(c)) {
+  if (gumbo_isalpha(c)) {
     gumbo_tokenizer_set_state(parser, GUMBO_LEX_RAWTEXT_END_TAG_NAME);
     start_new_tag(parser, false);
     append_char_to_temporary_buffer(parser, c);
@@ -1207,8 +1197,8 @@ static StateResult handle_rawtext_end_tag_name_state(
   assert(tokenizer->_temporary_buffer.length >= 2);
   gumbo_debug("Last end tag: %*s\n", (int) tokenizer->_tag_state._buffer.length,
              tokenizer->_tag_state._buffer.data);
-  if (is_alpha(c)) {
-    append_char_to_tag_buffer(parser, ensure_lowercase(c), true);
+  if (gumbo_isalpha(c)) {
+    append_char_to_tag_buffer(parser, gumbo_tolower(c), true);
     append_char_to_temporary_buffer(parser, c);
     return NEXT_CHAR;
   } else if (is_appropriate_end_tag(parser)) {
@@ -1261,7 +1251,7 @@ static StateResult handle_script_end_tag_open_state(
     GumboParser* parser, GumboTokenizerState* tokenizer,
     int c, GumboToken* output) {
   assert(temporary_buffer_equals(parser, "</"));
-  if (is_alpha(c)) {
+  if (gumbo_isalpha(c)) {
     gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_END_TAG_NAME);
     start_new_tag(parser, false);
     append_char_to_temporary_buffer(parser, c);
@@ -1277,8 +1267,8 @@ static StateResult handle_script_end_tag_name_state(
     GumboParser* parser, GumboTokenizerState* tokenizer,
     int c, GumboToken* output) {
   assert(tokenizer->_temporary_buffer.length >= 2);
-  if (is_alpha(c)) {
-    append_char_to_tag_buffer(parser, ensure_lowercase(c), true);
+  if (gumbo_isalpha(c)) {
+    append_char_to_tag_buffer(parser, gumbo_tolower(c), true);
     append_char_to_temporary_buffer(parser, c);
     return NEXT_CHAR;
   } else if (is_appropriate_end_tag(parser)) {
@@ -1420,11 +1410,11 @@ static StateResult handle_script_escaped_lt_state(
     gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED_END_TAG_OPEN);
     append_char_to_temporary_buffer(parser, c);
     return NEXT_CHAR;
-  } else if (is_alpha(c)) {
+  } else if (gumbo_isalpha(c)) {
     gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED_START);
     append_char_to_temporary_buffer(parser, c);
     gumbo_string_buffer_append_codepoint(
-        parser, ensure_lowercase(c), &tokenizer->_script_data_buffer);
+        gumbo_tolower(c), &tokenizer->_script_data_buffer);
     return emit_temporary_buffer(parser, output);
   } else {
     gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED);
@@ -1437,7 +1427,7 @@ static StateResult handle_script_escaped_end_tag_open_state(
     GumboParser* parser, GumboTokenizerState* tokenizer,
     int c, GumboToken* output) {
   assert(temporary_buffer_equals(parser, "</"));
-  if (is_alpha(c)) {
+  if (gumbo_isalpha(c)) {
     gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED_END_TAG_NAME);
     start_new_tag(parser, false);
     append_char_to_temporary_buffer(parser, c);
@@ -1453,8 +1443,8 @@ static StateResult handle_script_escaped_end_tag_name_state(
     GumboParser* parser, GumboTokenizerState* tokenizer,
     int c, GumboToken* output) {
   assert(tokenizer->_temporary_buffer.length >= 2);
-  if (is_alpha(c)) {
-    append_char_to_tag_buffer(parser, ensure_lowercase(c), true);
+  if (gumbo_isalpha(c)) {
+    append_char_to_tag_buffer(parser, gumbo_tolower(c), true);
     append_char_to_temporary_buffer(parser, c);
     return NEXT_CHAR;
   } else if (is_appropriate_end_tag(parser)) {
@@ -1497,9 +1487,9 @@ static StateResult handle_script_double_escaped_start_state(
           ? GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED : GUMBO_LEX_SCRIPT_ESCAPED);
       return emit_current_char(parser, output);
     default:
-      if (is_alpha(c)) {
+      if (gumbo_isalpha(c)) {
         gumbo_string_buffer_append_codepoint(
-            parser, ensure_lowercase(c), &tokenizer->_script_data_buffer);
+            gumbo_tolower(c), &tokenizer->_script_data_buffer);
         return emit_current_char(parser, output);
       } else {
         gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED);
@@ -1588,8 +1578,8 @@ static StateResult handle_script_double_escaped_lt_state(
     int c, GumboToken* output) {
   if (c == '/') {
     gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED_END);
-    gumbo_string_buffer_destroy(parser, &tokenizer->_script_data_buffer);
-    gumbo_string_buffer_init(parser, &tokenizer->_script_data_buffer);
+    gumbo_string_buffer_destroy(&tokenizer->_script_data_buffer);
+    gumbo_string_buffer_init(&tokenizer->_script_data_buffer);
     return emit_current_char(parser, output);
   } else {
     gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED);
@@ -1615,9 +1605,9 @@ static StateResult handle_script_double_escaped_end_state(
           ? GUMBO_LEX_SCRIPT_ESCAPED : GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED);
       return emit_current_char(parser, output);
     default:
-      if (is_alpha(c)) {
+      if (gumbo_isalpha(c)) {
         gumbo_string_buffer_append_codepoint(
-            parser, ensure_lowercase(c), &tokenizer->_script_data_buffer);
+            gumbo_tolower(c), &tokenizer->_script_data_buffer);
         return emit_current_char(parser, output);
       } else {
         gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED);
@@ -1661,7 +1651,7 @@ static StateResult handle_before_attr_name_state(
       // Fall through.
     default:
       gumbo_tokenizer_set_state(parser, GUMBO_LEX_ATTR_NAME);
-      append_char_to_tag_buffer(parser, ensure_lowercase(c), true);
+      append_char_to_tag_buffer(parser, gumbo_tolower(c), true);
       return NEXT_CHAR;
   }
 }
@@ -1705,7 +1695,7 @@ static StateResult handle_attr_name_state(
       tokenizer_add_parse_error(parser, GUMBO_ERR_ATTR_NAME_INVALID);
       // Fall through.
     default:
-      append_char_to_tag_buffer(parser, ensure_lowercase(c), true);
+      append_char_to_tag_buffer(parser, gumbo_tolower(c), true);
       return NEXT_CHAR;
   }
 }
@@ -1746,7 +1736,7 @@ static StateResult handle_after_attr_name_state(
       // Fall through.
     default:
       gumbo_tokenizer_set_state(parser, GUMBO_LEX_ATTR_NAME);
-      append_char_to_tag_buffer(parser, ensure_lowercase(c), true);
+      append_char_to_tag_buffer(parser, gumbo_tolower(c), true);
       return NEXT_CHAR;
   }
 }
@@ -2032,15 +2022,16 @@ static StateResult handle_markup_declaration_state(
     // the time to initialize the doctype strings.  (Not in doctype_state_init,
     // since then they'll leak if ownership never gets transferred to the
     // doctype token.
-    tokenizer->_doc_type_state.name = gumbo_copy_stringz(parser, "");
+    tokenizer->_doc_type_state.name = gumbo_strdup("");
     tokenizer->_doc_type_state.public_identifier =
-        gumbo_copy_stringz(parser, "");
+        gumbo_strdup("");
     tokenizer->_doc_type_state.system_identifier =
-        gumbo_copy_stringz(parser, "");
+        gumbo_strdup("");
   } else if (tokenizer->_is_current_node_foreign &&
              utf8iterator_maybe_consume_match(
                 &tokenizer->_input, "[CDATA[", sizeof("[CDATA[") - 1, true)) {
     gumbo_tokenizer_set_state(parser, GUMBO_LEX_CDATA);
+    tokenizer->_is_in_cdata = true;
     tokenizer->_reconsume_current_input = true;
   } else {
     tokenizer_add_parse_error(parser, GUMBO_ERR_DASHES_OR_DOCTYPE);
@@ -2296,7 +2287,7 @@ static StateResult handle_before_doctype_name_state(
     default:
       gumbo_tokenizer_set_state(parser, GUMBO_LEX_DOCTYPE_NAME);
       tokenizer->_doc_type_state.force_quirks = false;
-      append_char_to_temporary_buffer(parser, ensure_lowercase(c));
+      append_char_to_temporary_buffer(parser, gumbo_tolower(c));
       return NEXT_CHAR;
   }
 }
@@ -2311,13 +2302,13 @@ static StateResult handle_doctype_name_state(
     case '\f':
     case ' ':
       gumbo_tokenizer_set_state(parser, GUMBO_LEX_AFTER_DOCTYPE_NAME);
-      gumbo_parser_deallocate(parser, (void*) tokenizer->_doc_type_state.name);
+      gumbo_free((void*) tokenizer->_doc_type_state.name);
       finish_temporary_buffer(
           parser, &tokenizer->_doc_type_state.name);
       return NEXT_CHAR;
     case '>':
       gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
-      gumbo_parser_deallocate(parser, (void*) tokenizer->_doc_type_state.name);
+      gumbo_free((void*) tokenizer->_doc_type_state.name);
       finish_temporary_buffer(
           parser, &tokenizer->_doc_type_state.name);
       emit_doctype(parser, output);
@@ -2330,7 +2321,7 @@ static StateResult handle_doctype_name_state(
       tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_EOF);
       gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
       tokenizer->_doc_type_state.force_quirks = true;
-      gumbo_parser_deallocate(parser, (void*) tokenizer->_doc_type_state.name);
+      gumbo_free((void*) tokenizer->_doc_type_state.name);
       finish_temporary_buffer(
           parser, &tokenizer->_doc_type_state.name);
       emit_doctype(parser, output);
@@ -2338,7 +2329,7 @@ static StateResult handle_doctype_name_state(
     default:
       gumbo_tokenizer_set_state(parser, GUMBO_LEX_DOCTYPE_NAME);
       tokenizer->_doc_type_state.force_quirks = false;
-      append_char_to_temporary_buffer(parser, ensure_lowercase(c));
+      append_char_to_temporary_buffer(parser, gumbo_tolower(c));
       return NEXT_CHAR;
   }
 }
@@ -2814,6 +2805,7 @@ static StateResult handle_cdata_state(
     tokenizer->_reconsume_current_input = true;
     reset_token_start_point(tokenizer);
     gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
+    tokenizer->_is_in_cdata = true;
     return NEXT_CHAR;
   } else {
     return emit_current_char(parser, output);
@@ -2930,7 +2922,8 @@ bool gumbo_lex(GumboParser* parser, GumboToken* output) {
     assert(!tokenizer->_temporary_buffer_emit);
     assert(tokenizer->_buffered_emit_char == kGumboNoChar);
     int c = utf8iterator_current(&tokenizer->_input);
-    gumbo_debug("Lexing character '%c' in state %d.\n", c, tokenizer->_state);
+    gumbo_debug("Lexing character '%c' (%d) in state %d.\n",
+        c, c, tokenizer->_state);
     StateResult result =
         dispatch_table[tokenizer->_state](parser, tokenizer, c, output);
     // We need to clear reconsume_current_input before returning to prevent
@@ -2950,30 +2943,27 @@ bool gumbo_lex(GumboParser* parser, GumboToken* output) {
   }
 }
 
-void gumbo_token_destroy(GumboParser* parser, GumboToken* token) {
+void gumbo_token_destroy(GumboToken* token) {
   if (!token) return;
 
   switch (token->type) {
     case GUMBO_TOKEN_DOCTYPE:
-      gumbo_parser_deallocate(parser, (void*) token->v.doc_type.name);
-      gumbo_parser_deallocate(
-          parser, (void*) token->v.doc_type.public_identifier);
-      gumbo_parser_deallocate(
-          parser, (void*) token->v.doc_type.system_identifier);
+      gumbo_free((void*) token->v.doc_type.name);
+      gumbo_free((void*) token->v.doc_type.public_identifier);
+      gumbo_free((void*) token->v.doc_type.system_identifier);
       return;
     case GUMBO_TOKEN_START_TAG:
       for (int i = 0; i < token->v.start_tag.attributes.length; ++i) {
         GumboAttribute* attr = token->v.start_tag.attributes.data[i];
         if (attr) {
           // May have been nulled out if this token was merged with another.
-          gumbo_destroy_attribute(parser, attr);
+          gumbo_destroy_attribute(attr);
         }
       }
-      gumbo_parser_deallocate(
-          parser, (void*) token->v.start_tag.attributes.data);
+      gumbo_free((void*) token->v.start_tag.attributes.data);
       return;
     case GUMBO_TOKEN_COMMENT:
-      gumbo_parser_deallocate(parser, (void*) token->v.text);
+      gumbo_free((void*) token->v.text);
       return;
     default:
       return;
diff --git a/src/tokenizer.h b/src/tokenizer.h
index aacb72cc..baabeb01 100644
--- a/src/tokenizer.h
+++ b/src/tokenizer.h
@@ -114,7 +114,7 @@ bool gumbo_lex(struct GumboInternalParser* parser, GumboToken* output);
 // Note that if you are handing over ownership of the internal strings to some
 // other data structure - for example, a parse tree - these do not need to be
 // freed.
-void gumbo_token_destroy(struct GumboInternalParser* parser, GumboToken* token);
+void gumbo_token_destroy(GumboToken* token);
 
 #ifdef __cplusplus
 }
diff --git a/src/utf8.c b/src/utf8.c
index a5c5b0e2..a6a30376 100644
--- a/src/utf8.c
+++ b/src/utf8.c
@@ -133,10 +133,10 @@ static void read_char(Utf8Iterator* iter) {
     decode(&state, &code_point, (uint32_t) (unsigned char) (*c));
     if (state == UTF8_ACCEPT) {
       iter->_width = c - iter->_start + 1;
-      // This is the special handling for carriage returns that is mandated by the
-      // HTML5 spec.  Since we're looking for particular 7-bit literal characters,
-      // we operate in terms of chars and only need a check for iter overrun,
-      // instead of having to read in a full next code point.
+      // This is the special handling for carriage returns that is mandated by
+      // the HTML5 spec.  Since we're looking for particular 7-bit literal
+      // characters, we operate in terms of chars and only need a check for iter
+      // overrun, instead of having to read in a full next code point.
       // http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#preprocessing-the-input-stream
       if (code_point == '\r') {
         assert(iter->_width == 1);
@@ -165,10 +165,11 @@ static void read_char(Utf8Iterator* iter) {
       return;
     }
   }
-  // If we got here without exiting early, then we've reached the end of the iterator.
-  // Add an error for truncated input, set the width to consume the rest of the
-  // iterator, and emit a replacement character.  The next time we enter this method,
-  // it will detect that there's no input to consume and 
+  // If we got here without exiting early, then we've reached the end of the
+  // iterator.  Add an error for truncated input, set the width to consume the
+  // rest of the iterator, and emit a replacement character.  The next time we
+  // enter this method, it will detect that there's no input to consume and
+  // output an EOF.
   iter->_current = kUtf8ReplacementChar;
   iter->_width = iter->_end - iter->_start;
   add_error(iter, GUMBO_ERR_UTF8_TRUNCATED);
diff --git a/src/util.c b/src/util.c
index a3dafd79..079b2246 100644
--- a/src/util.c
+++ b/src/util.c
@@ -31,18 +31,21 @@
 // as any.
 const GumboSourcePosition kGumboEmptySourcePosition = { 0, 0, 0 };
 
-void* gumbo_parser_allocate(GumboParser* parser, size_t num_bytes) {
-  return parser->_options->allocator(parser->_options->userdata, num_bytes);
+/*
+ * Default memory management helpers;
+ * set to system's realloc and free by default
+ */
+void *(* gumbo_user_allocator)(void *, size_t) = realloc;
+void (* gumbo_user_free)(void *) = free;
+
+void gumbo_memory_set_allocator(void *(*allocator_p)(void *, size_t))
+{
+  gumbo_user_allocator = allocator_p ? allocator_p : realloc;
 }
 
-void gumbo_parser_deallocate(GumboParser* parser, void* ptr) {
-  parser->_options->deallocator(parser->_options->userdata, ptr);
-}
-
-char* gumbo_copy_stringz(GumboParser* parser, const char* str) {
-  char* buffer = gumbo_parser_allocate(parser, strlen(str) + 1);
-  strcpy(buffer, str);
-  return buffer;
+void gumbo_memory_set_free(void (*free_p)(void *))
+{
+  gumbo_user_free = free_p ? free_p : free;
 }
 
 // Debug function to trace operation of the parser.  Pass --copts=-DGUMBO_DEBUG
diff --git a/src/util.h b/src/util.h
index 28b6905b..e51f53b6 100644
--- a/src/util.h
+++ b/src/util.h
@@ -24,32 +24,48 @@
 #endif
 #include <stdbool.h>
 #include <stddef.h>
-
-
+#include <stdlib.h>
+#include <string.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-// Forward declaration since it's passed into some of the functions in this
-// header.
-struct GumboInternalParser;
-
-// Utility function for allocating & copying a null-terminated string into a
-// freshly-allocated buffer.  This is necessary for proper memory management; we
-// have the convention that all const char* in parse tree structures are
-// freshly-allocated, so if we didn't copy, we'd try to delete a literal string
-// when the parse tree is destroyed.
-char* gumbo_copy_stringz(struct GumboInternalParser* parser, const char* str);
-
-// Allocate a chunk of memory, using the allocator specified in the Parser's
-// config options.
-void* gumbo_parser_allocate(
-    struct GumboInternalParser* parser, size_t num_bytes);
-
-// Deallocate a chunk of memory, using the deallocator specified in the Parser's
-// config options.
-void gumbo_parser_deallocate(struct GumboInternalParser* parser, void* ptr);
+extern void *(* gumbo_user_allocator)(void *, size_t);
+extern void (* gumbo_user_free)(void *);
+
+static inline void *gumbo_malloc(size_t size)
+{
+  return gumbo_user_allocator(NULL, size);
+}
+
+static inline void *gumbo_realloc(void *ptr, size_t size)
+{
+  return gumbo_user_allocator(ptr, size);
+}
+
+static inline char *gumbo_strdup(const char *str)
+{
+  size_t len = strlen(str) + 1;
+  char *copy = (char *)gumbo_malloc(len);
+  memcpy(copy, str, len);
+  return copy;
+}
+
+static inline void gumbo_free(void *ptr)
+{
+  gumbo_user_free(ptr);
+}
+
+static inline int gumbo_tolower(int c)
+{
+  return c | ((c >= 'A' && c <= 'Z') << 5);
+}
+
+static inline bool gumbo_isalpha(int c)
+{
+  return (c | 0x20) >= 'a' && (c | 0x20) <= 'z';
+}
 
 // Debug wrapper for printf, to make it easier to turn off debugging info when
 // required.
diff --git a/src/vector.c b/src/vector.c
index f6b7d88d..5ae8033c 100644
--- a/src/vector.c
+++ b/src/vector.c
@@ -27,61 +27,50 @@ struct GumboInternalParser;
 
 const GumboVector kGumboEmptyVector = { NULL, 0, 0 };
 
-void gumbo_vector_init(
-    struct GumboInternalParser* parser, size_t initial_capacity, GumboVector* vector) {
+void gumbo_vector_init(size_t initial_capacity, GumboVector* vector) {
   vector->length = 0;
   vector->capacity = initial_capacity;
-  if (initial_capacity > 0) {
-    vector->data = gumbo_parser_allocate(
-        parser, sizeof(void*) * initial_capacity);
-  } else {
-    vector->data = NULL;
-  }
+  vector->data = NULL;
+  if (initial_capacity)
+    vector->data = gumbo_malloc(sizeof(void*) * initial_capacity);
 }
 
-void gumbo_vector_destroy(struct GumboInternalParser* parser, GumboVector* vector) {
-  if (vector->capacity > 0) {
-    gumbo_parser_deallocate(parser, vector->data);
-  }
+void gumbo_vector_destroy(GumboVector* vector) {
+  gumbo_free(vector->data);
 }
 
-static void enlarge_vector_if_full(
-    struct GumboInternalParser* parser, GumboVector* vector) {
-  if (vector->length >= vector->capacity) {
-    if (vector->capacity) {
-      size_t old_num_bytes = sizeof(void*) * vector->capacity;
-      vector->capacity *= 2;
-      size_t num_bytes = sizeof(void*) * vector->capacity;
-      void** temp = gumbo_parser_allocate(parser, num_bytes);
-      memcpy(temp, vector->data, old_num_bytes);
-      gumbo_parser_deallocate(parser, vector->data);
-      vector->data = temp;
-    } else {
-      // 0-capacity vector; no previous array to deallocate.
-      vector->capacity = 2;
-      vector->data = gumbo_parser_allocate(
-          parser, sizeof(void*) * vector->capacity);
-    }
+static void enlarge_vector_if_full(GumboVector* vector, int space) {
+  unsigned int new_length = vector->length + space;
+  unsigned int new_capacity = vector->capacity;
+
+  if (!new_capacity)
+    new_capacity = 2;
+
+  while (new_capacity < new_length)
+    new_capacity *= 2;
+
+  if (new_capacity != vector->capacity) {
+    vector->capacity = new_capacity;
+    vector->data = gumbo_realloc(vector->data,
+        sizeof(void *) * vector->capacity);
   }
 }
 
-void gumbo_vector_add(
-    struct GumboInternalParser* parser, void* element, GumboVector* vector) {
-  enlarge_vector_if_full(parser, vector);
+void gumbo_vector_add(void* element, GumboVector* vector) {
+  enlarge_vector_if_full(vector, 1);
   assert(vector->data);
   assert(vector->length < vector->capacity);
   vector->data[vector->length++] = element;
 }
 
-void* gumbo_vector_pop(
-    struct GumboInternalParser* parser, GumboVector* vector) {
+void* gumbo_vector_pop(GumboVector* vector) {
   if (vector->length == 0) {
     return NULL;
   }
   return vector->data[--vector->length];
 }
 
-int gumbo_vector_index_of(GumboVector* vector, void* element) {
+int gumbo_vector_index_of(GumboVector* vector, const void* element) {
   for (int i = 0; i < vector->length; ++i) {
     if (vector->data[i] == element) {
       return i;
@@ -90,34 +79,41 @@ int gumbo_vector_index_of(GumboVector* vector, void* element) {
   return -1;
 }
 
-void gumbo_vector_insert_at(
-    struct GumboInternalParser* parser, void* element, int index,
-    GumboVector* vector) {
+void gumbo_vector_insert_at(void* element, int index, GumboVector* vector) {
   assert(index >= 0);
   assert(index <= vector->length);
-  enlarge_vector_if_full(parser, vector);
+  enlarge_vector_if_full(vector, 1);
   ++vector->length;
   memmove(&vector->data[index + 1], &vector->data[index],
-          sizeof(void*) * (vector->length - index - 1));
+      sizeof(void*) * (vector->length - index - 1));
   vector->data[index] = element;
 }
 
-void gumbo_vector_remove(
-    struct GumboInternalParser* parser, void* node, GumboVector* vector) {
+void gumbo_vector_splice(int where, int n_to_remove,
+    void **data, int n_to_insert,
+    GumboVector* vector) {
+  enlarge_vector_if_full(vector, n_to_insert - n_to_remove);
+  memmove(vector->data + where + n_to_insert,
+      vector->data + where + n_to_remove,
+      sizeof(void *) * (vector->length - where - n_to_remove));
+  memcpy(vector->data + where, data, sizeof(void *) * n_to_insert);
+  vector->length = vector->length + n_to_insert - n_to_remove;
+}
+
+void gumbo_vector_remove(const void* node, GumboVector* vector) {
   int index = gumbo_vector_index_of(vector, node);
   if (index == -1) {
     return;
   }
-  gumbo_vector_remove_at(parser, index, vector);
+  gumbo_vector_remove_at(index, vector);
 }
 
-void* gumbo_vector_remove_at(
-    struct GumboInternalParser* parser, int index, GumboVector* vector) {
+void* gumbo_vector_remove_at(int index, GumboVector* vector) {
   assert(index >= 0);
   assert(index < vector->length);
   void* result = vector->data[index];
   memmove(&vector->data[index], &vector->data[index + 1],
-          sizeof(void*) * (vector->length - index - 1));
+      sizeof(void*) * (vector->length - index - 1));
   --vector->length;
   return result;
 }
diff --git a/src/vector.h b/src/vector.h
index a78f20de..dd831e81 100644
--- a/src/vector.h
+++ b/src/vector.h
@@ -23,44 +23,37 @@
 extern "C" {
 #endif
 
-// Forward declaration since it's passed into some of the functions in this
-// header.
-struct GumboInternalParser;
-
 // Initializes a new GumboVector with the specified initial capacity.
-void gumbo_vector_init(
-    struct GumboInternalParser* parser, size_t initial_capacity,
-    GumboVector* vector);
+void gumbo_vector_init(size_t initial_capacity, GumboVector* vector);
 
 // Frees the memory used by an GumboVector.  Does not free the contained
 // pointers.
-void gumbo_vector_destroy(
-    struct GumboInternalParser* parser, GumboVector* vector);
+void gumbo_vector_destroy(GumboVector* vector);
 
 // Adds a new element to an GumboVector.
-void gumbo_vector_add(
-    struct GumboInternalParser* parser, void* element, GumboVector* vector);
+void gumbo_vector_add(void* element, GumboVector* vector);
 
 // Removes and returns the element most recently added to the GumboVector.
 // Ownership is transferred to caller.  Capacity is unchanged.  If the vector is
 // empty, NULL is returned.
-void* gumbo_vector_pop(struct GumboInternalParser* parser, GumboVector* vector);
+void* gumbo_vector_pop(GumboVector* vector);
 
 // Inserts an element at a specific index.  This is potentially O(N) time, but
 // is necessary for some of the spec's behavior.
-void gumbo_vector_insert_at(
-    struct GumboInternalParser* parser, void* element, int index,
-    GumboVector* vector);
+void gumbo_vector_insert_at(void* element, int index, GumboVector* vector);
 
 // Removes an element from the vector, or does nothing if the element is not in
 // the vector.
-void gumbo_vector_remove(
-    struct GumboInternalParser* parser, void* element, GumboVector* vector);
+void gumbo_vector_remove(const void* element, GumboVector* vector);
 
 // Removes and returns an element at a specific index.  Note that this is
 // potentially O(N) time and should be used sparingly.
-void* gumbo_vector_remove_at(
-    struct GumboInternalParser* parser, int index, GumboVector* vector);
+void* gumbo_vector_remove_at(int index, GumboVector* vector);
+
+int gumbo_vector_index_of(GumboVector* vector, const void* element);
+
+void gumbo_vector_splice(
+	int where, int n_to_remove, void **data, int n_to_insert, GumboVector* vector);
 
 #ifdef __cplusplus
 }
diff --git a/tests/attribute.cc b/tests/attribute.cc
index 8f0cca29..db7759d5 100644
--- a/tests/attribute.cc
+++ b/tests/attribute.cc
@@ -28,11 +28,11 @@ namespace {
 class GumboAttributeTest : public GumboTest {
  protected:
   GumboAttributeTest() {
-    gumbo_vector_init(&parser_, 2, &vector_);
+    gumbo_vector_init(2, &vector_);
   }
 
   ~GumboAttributeTest() {
-    gumbo_vector_destroy(&parser_, &vector_);
+    gumbo_vector_destroy(&vector_);
   }
 
   GumboVector vector_;
@@ -44,8 +44,8 @@ TEST_F(GumboAttributeTest, GetAttribute) {
   attr1.name = "";
   attr2.name = "foo";
 
-  gumbo_vector_add(&parser_, &attr1, &vector_);
-  gumbo_vector_add(&parser_, &attr2, &vector_);
+  gumbo_vector_add(&attr1, &vector_);
+  gumbo_vector_add(&attr2, &vector_);
   EXPECT_EQ(&attr2, gumbo_get_attribute(&vector_, "foo"));
   EXPECT_EQ(NULL, gumbo_get_attribute(&vector_, "bar"));
 }
diff --git a/tests/parser.cc b/tests/parser.cc
index e565a248..c7a947f3 100644
--- a/tests/parser.cc
+++ b/tests/parser.cc
@@ -30,13 +30,13 @@ class GumboParserTest : public ::testing::Test {
 
   virtual ~GumboParserTest() {
     if (output_) {
-      gumbo_destroy_output(&options_, output_);
+      gumbo_destroy_output(output_);
     }
   }
 
   virtual void Parse(const char* input) {
     if (output_) {
-      gumbo_destroy_output(&options_, output_);
+      gumbo_destroy_output(output_);
     }
 
     output_ = gumbo_parse_with_options(&options_, input, strlen(input));
@@ -50,7 +50,7 @@ class GumboParserTest : public ::testing::Test {
     // This overload is so we can test/demonstrate that computing offsets from
     // the .data() member of an STL string works properly.
     if (output_) {
-      gumbo_destroy_output(&options_, output_);
+      gumbo_destroy_output(output_);
     }
 
     output_ = gumbo_parse_with_options(&options_, input.data(), input.length());
@@ -1491,6 +1491,10 @@ TEST_F(GumboParserTest, AdoptionAgency2) {
   EXPECT_STREQ("3", text3->v.text.text);
 }
 
+TEST_F(GumboParserTest, AdoptionAgency3) {
+  Parse("<div><a><b><u><i><code><div></a>");
+}
+
 TEST_F(GumboParserTest, ImplicitlyCloseLists) {
   Parse("<ul>\n"
         "  <li>First\n"
@@ -1522,6 +1526,57 @@ TEST_F(GumboParserTest, ImplicitlyCloseLists) {
   ASSERT_EQ(1, GetChildCount(li2));
 }
 
+TEST_F(GumboParserTest, CData) {
+  Parse("<svg><![CDATA[this is text]]></svg>");
+
+  GumboNode* body;
+  GetAndAssertBody(root_, &body);
+  ASSERT_EQ(1, GetChildCount(body));
+
+  GumboNode* svg = GetChild(body, 0);
+  ASSERT_EQ(1, GetChildCount(svg));
+
+  GumboNode* cdata = GetChild(svg, 0);
+  ASSERT_EQ(GUMBO_NODE_CDATA, cdata->type);
+  EXPECT_STREQ("this is text", cdata->v.text.text);
+}
+
+TEST_F(GumboParserTest, CDataUnsafe) {
+  // Can't use Parse() because of the strlen
+  output_ = gumbo_parse_with_options(
+      &options_, "<svg><![CDATA[\0filler\0text\0]]>",
+      sizeof("<svg><![CDATA[\0filler\0text\0]]>") - 1);
+  root_ = output_->document;
+
+  GumboNode* body;
+  GetAndAssertBody(root_, &body);
+  ASSERT_EQ(1, GetChildCount(body));
+
+  GumboNode* svg = GetChild(body, 0);
+  ASSERT_EQ(1, GetChildCount(svg));
+
+  GumboNode* cdata = GetChild(svg, 0);
+  ASSERT_EQ(GUMBO_NODE_CDATA, cdata->type);
+  // \xEF\xBF\xBD = unicode replacement char
+  EXPECT_STREQ("\xEF\xBF\xBD" "filler\xEF\xBF\xBD" "text\xEF\xBF\xBD",
+      cdata->v.text.text);
+}
+
+TEST_F(GumboParserTest, CDataInBody) {
+  Parse("<div><![CDATA[this is text]]></div>");
+
+  GumboNode* body;
+  GetAndAssertBody(root_, &body);
+  ASSERT_EQ(1, GetChildCount(body));
+
+  GumboNode* div = GetChild(body, 0);
+  ASSERT_EQ(1, GetChildCount(div));
+
+  GumboNode* cdata = GetChild(div, 0);
+  ASSERT_EQ(GUMBO_NODE_COMMENT, cdata->type);
+  EXPECT_STREQ("[CDATA[this is text]]", cdata->v.text.text);
+}
+
 TEST_F(GumboParserTest, FormattingTagsInHeading) {
   Parse("<h2>This is <b>old</h2>text");
 
@@ -1802,4 +1857,35 @@ TEST_F(GumboParserTest, TdInMathml) {
   ASSERT_EQ(0, GetChildCount(td));
 }
 
+TEST_F(GumboParserTest, TestTemplateInForeignContent) {
+  Parse("<template><svg><template>");
+
+  GumboNode* body;
+  GetAndAssertBody(root_, &body);
+  EXPECT_EQ(0, GetChildCount(body));
+
+  GumboNode* html = GetChild(root_, 0);
+  ASSERT_EQ(2, GetChildCount(html));
+
+  GumboNode* head = GetChild(html, 0);
+  ASSERT_EQ(1, GetChildCount(head));
+
+  GumboNode* template_node = GetChild(head, 0);
+  ASSERT_EQ(GUMBO_NODE_TEMPLATE, template_node->type);
+  EXPECT_EQ(GUMBO_TAG_TEMPLATE, template_node->v.element.tag);
+  ASSERT_EQ(1, GetChildCount(template_node));
+
+  GumboNode* svg_node = GetChild(template_node, 0);
+  ASSERT_EQ(GUMBO_NODE_ELEMENT, svg_node->type);
+  EXPECT_EQ(GUMBO_TAG_SVG, svg_node->v.element.tag);
+  EXPECT_EQ(GUMBO_NAMESPACE_SVG, svg_node->v.element.tag_namespace);
+  ASSERT_EQ(1, GetChildCount(svg_node));
+
+  GumboNode* svg_template = GetChild(svg_node, 0);
+  ASSERT_EQ(GUMBO_NODE_ELEMENT, svg_template->type);
+  EXPECT_EQ(GUMBO_TAG_TEMPLATE, svg_template->v.element.tag);
+  EXPECT_EQ(GUMBO_NAMESPACE_SVG, svg_template->v.element.tag_namespace);
+  EXPECT_EQ(0, GetChildCount(svg_template));
+}
+
 }  // namespace
diff --git a/tests/string_buffer.cc b/tests/string_buffer.cc
index b8966cf8..ab5a0d49 100644
--- a/tests/string_buffer.cc
+++ b/tests/string_buffer.cc
@@ -31,11 +31,11 @@ namespace {
 class GumboStringBufferTest : public GumboTest {
  protected:
   GumboStringBufferTest() {
-    gumbo_string_buffer_init(&parser_, &buffer_);
+    gumbo_string_buffer_init(&buffer_);
   }
 
   ~GumboStringBufferTest() {
-    gumbo_string_buffer_destroy(&parser_, &buffer_);
+    gumbo_string_buffer_destroy(&buffer_);
   }
 
   void NullTerminateBuffer() {
@@ -46,7 +46,7 @@ class GumboStringBufferTest : public GumboTest {
 };
 
 TEST_F(GumboStringBufferTest, Reserve) {
-  gumbo_string_buffer_reserve(&parser_, 21, &buffer_);
+  gumbo_string_buffer_reserve(21, &buffer_);
   EXPECT_EQ(40, buffer_.capacity);
   strcpy(buffer_.data, "01234567890123456789");
   buffer_.length = 20;
@@ -57,39 +57,39 @@ TEST_F(GumboStringBufferTest, Reserve) {
 
 TEST_F(GumboStringBufferTest, AppendString) {
   INIT_GUMBO_STRING(str, "01234567");
-  gumbo_string_buffer_append_string(&parser_, &str, &buffer_);
+  gumbo_string_buffer_append_string(&str, &buffer_);
   NullTerminateBuffer();
   EXPECT_STREQ("01234567", buffer_.data);
 }
 
 TEST_F(GumboStringBufferTest, AppendStringWithResize) {
   INIT_GUMBO_STRING(str, "01234567");
-  gumbo_string_buffer_append_string(&parser_, &str, &buffer_);
-  gumbo_string_buffer_append_string(&parser_, &str, &buffer_);
+  gumbo_string_buffer_append_string(&str, &buffer_);
+  gumbo_string_buffer_append_string(&str, &buffer_);
   NullTerminateBuffer();
   EXPECT_STREQ("0123456701234567", buffer_.data);
 }
 
 TEST_F(GumboStringBufferTest, AppendCodepoint_1Byte) {
-  gumbo_string_buffer_append_codepoint(&parser_, 'a', &buffer_);
+  gumbo_string_buffer_append_codepoint('a', &buffer_);
   NullTerminateBuffer();
   EXPECT_STREQ("a", buffer_.data);
 }
 
 TEST_F(GumboStringBufferTest, AppendCodepoint_2Bytes) {
-  gumbo_string_buffer_append_codepoint(&parser_, 0xE5, &buffer_);
+  gumbo_string_buffer_append_codepoint(0xE5, &buffer_);
   NullTerminateBuffer();
   EXPECT_STREQ("\xC3\xA5", buffer_.data);
 }
 
 TEST_F(GumboStringBufferTest, AppendCodepoint_3Bytes) {
-  gumbo_string_buffer_append_codepoint(&parser_, 0x39E7, &buffer_);
+  gumbo_string_buffer_append_codepoint(0x39E7, &buffer_);
   NullTerminateBuffer();
   EXPECT_STREQ("\xE3\xA7\xA7", buffer_.data);
 }
 
 TEST_F(GumboStringBufferTest, AppendCodepoint_4Bytes) {
-  gumbo_string_buffer_append_codepoint(&parser_, 0x679E7, &buffer_);
+  gumbo_string_buffer_append_codepoint(0x679E7, &buffer_);
   NullTerminateBuffer();
   EXPECT_STREQ("\xF1\xA7\xA7\xA7", buffer_.data);
 }
@@ -98,9 +98,9 @@ TEST_F(GumboStringBufferTest, ToString) {
   strcpy(buffer_.data, "012345");
   buffer_.length = 7;
 
-  char* dest = gumbo_string_buffer_to_string(&parser_, &buffer_);
+  char* dest = gumbo_string_buffer_to_string(&buffer_);
   EXPECT_STREQ("012345", dest);
-  gumbo_parser_deallocate(&parser_, dest);
+  gumbo_free(dest);
 }
 
 }  // namespace
diff --git a/tests/string_piece.cc b/tests/string_piece.cc
index 965ee5aa..29b3dfbe 100644
--- a/tests/string_piece.cc
+++ b/tests/string_piece.cc
@@ -74,13 +74,11 @@ TEST_F(GumboStringPieceTest, CaseNotEqual_Str2Shorter) {
 }
 
 TEST_F(GumboStringPieceTest, Copy) {
-  GumboParser parser;
-  parser._options = &kGumboDefaultOptions;
   INIT_GUMBO_STRING(str1, "bar");
   GumboStringPiece str2;
-  gumbo_string_copy(&parser, &str2, &str1);
+  gumbo_string_copy(&str2, &str1);
   EXPECT_TRUE(gumbo_string_equals(&str1, &str2));
-  gumbo_parser_deallocate(&parser, (void*) str2.data);
+  gumbo_free((void*) str2.data);
 }
 
 }  // namespace
diff --git a/tests/test_utils.cc b/tests/test_utils.cc
index 7fc47711..0eb92682 100644
--- a/tests/test_utils.cc
+++ b/tests/test_utils.cc
@@ -142,54 +142,27 @@ void SanityCheckPointers(const char* input, size_t input_length,
   }
 }
 
-// Custom allocator machinery to sanity check for memory leaks.  Normally we can
-// use heapcheck/valgrind/ASAN for this, but they only give the
-// results when the program terminates.  This means that if the parser is run in
-// a loop (say, a MapReduce) and there's a leak, it may end up exhausting memory
-// before it can catch the particular document responsible for the leak.  These
-// allocators let us check each document individually for leaks.
-
-static void* LeakDetectingMalloc(void* userdata, size_t size) {
-  MallocStats* stats = static_cast<MallocStats*>(userdata);
-  stats->bytes_allocated += size;
-  ++stats->objects_allocated;
-  // Arbitrary limit of 2G on allocation; parsing any reasonable document
-  // shouldn't take more than that.
-  assert(stats->bytes_allocated < (1 << 31));
-  void* obj = malloc(size);
-  // gumbo_debug("Allocated %u bytes at %x.\n", size, obj);
-  return obj;
-}
-
-static void LeakDetectingFree(void* userdata, void* ptr) {
-  MallocStats* stats = static_cast<MallocStats*>(userdata);
-  if (ptr) {
-    ++stats->objects_freed;
-    // gumbo_debug("Freed %x.\n");
-    free(ptr);
-  }
-}
-
-void InitLeakDetection(GumboOptions* options, MallocStats* stats) {
-  stats->bytes_allocated = 0;
-  stats->objects_allocated = 0;
-  stats->objects_freed = 0;
-
-  options->allocator = LeakDetectingMalloc;
-  options->deallocator = LeakDetectingFree;
-  options->userdata = stats;
-}
-
+/*
+ * NOTE:vmg
+ *
+ * The test suite used to have a very basic memory-checking allocator;
+ * since we've simplified the API for defining custom memory allocators,
+ * it is not trivial to implement the memcheck allocator naively. The new
+ * API maps `realloc` calls (instead of `malloc` and `free`), which means
+ * that you need to keep track of memory resizes and you can't just add and
+ * substract allocated memory. Hence, the implementation of a naive memory
+ * leak detector becomes more complex; it is still definitely doable, but at
+ * that point we might as well wire up tcmalloc with its memleak allocator,
+ * or simply run the suite under Valgrind
+ */
 
 GumboTest::GumboTest() :
     options_(kGumboDefaultOptions),
     errors_are_expected_(false),
     text_("")  {
-  InitLeakDetection(&options_, &malloc_stats_);
   options_.max_errors = 100;
   parser_._options = &options_;
-  parser_._output = static_cast<GumboOutput*>(
-      gumbo_parser_allocate(&parser_, sizeof(GumboOutput)));
+  parser_._output = static_cast<GumboOutput*>(gumbo_malloc(sizeof(GumboOutput)));
   gumbo_init_errors(&parser_);
 }
 
@@ -200,11 +173,10 @@ GumboTest::~GumboTest() {
     // output of the test.
     for (int i = 0; i < parser_._output->errors.length && i < 1; ++i) {
       gumbo_print_caret_diagnostic(
-          &parser_, static_cast<GumboError*>(
+          static_cast<GumboError*>(
               parser_._output->errors.data[i]), text_);
     }
   }
   gumbo_destroy_errors(&parser_);
-  gumbo_parser_deallocate(&parser_, parser_._output);
-  EXPECT_EQ(malloc_stats_.objects_allocated, malloc_stats_.objects_freed);
+  gumbo_free(parser_._output);
 }
diff --git a/tests/tokenizer.cc b/tests/tokenizer.cc
index 532bad98..9316e438 100644
--- a/tests/tokenizer.cc
+++ b/tests/tokenizer.cc
@@ -34,7 +34,7 @@ class GumboTokenizerTest : public GumboTest {
 
   virtual ~GumboTokenizerTest() {
     gumbo_tokenizer_state_destroy(&parser_);
-    gumbo_token_destroy(&parser_, &token_);
+    gumbo_token_destroy(&token_);
   }
 
   void SetInput(const char* input) {
@@ -46,7 +46,7 @@ class GumboTokenizerTest : public GumboTest {
   void Advance(int num_tokens) {
     for (int i = 0; i < num_tokens; ++i) {
       EXPECT_TRUE(gumbo_lex(&parser_, &token_));
-      gumbo_token_destroy(&parser_, &token_);
+      gumbo_token_destroy(&token_);
     }
   }
 
@@ -54,7 +54,7 @@ class GumboTokenizerTest : public GumboTest {
 };
 
 TEST(GumboTagEnumTest, TagEnumIncludesAllTags) {
-  EXPECT_EQ(149, GUMBO_TAG_UNKNOWN);
+  EXPECT_EQ(150, GUMBO_TAG_UNKNOWN);
   EXPECT_STREQ("", kGumboTagNames[GUMBO_TAG_UNKNOWN]);
 }
 
@@ -210,22 +210,22 @@ TEST_F(GumboTokenizerTest, RawtextEnd) {
   EXPECT_EQ(GUMBO_TAG_TITLE, token_.v.start_tag.tag);
 
   gumbo_tokenizer_set_state(&parser_, GUMBO_LEX_RAWTEXT);
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ('x', token_.v.character);
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
 
   Advance(9);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ('<', token_.v.character);
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
 
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ('t', token_.v.character);
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
 
   Advance(3);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
@@ -240,12 +240,12 @@ TEST_F(GumboTokenizerTest, RCDataEnd) {
   EXPECT_EQ(GUMBO_TAG_TITLE, token_.v.start_tag.tag);
 
   gumbo_tokenizer_set_state(&parser_, GUMBO_LEX_RCDATA);
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ('x', token_.v.character);
 
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_END_TAG, token_.type);
   EXPECT_EQ(GUMBO_TAG_TITLE, token_.v.end_tag);
@@ -258,28 +258,28 @@ TEST_F(GumboTokenizerTest, ScriptEnd) {
   EXPECT_EQ(GUMBO_TAG_SCRIPT, token_.v.start_tag.tag);
 
   gumbo_tokenizer_set_state(&parser_, GUMBO_LEX_SCRIPT);
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ('x', token_.v.character);
 
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   Advance(6);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ('<', token_.v.character);
 
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ('/', token_.v.character);
 
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ('\'', token_.v.character);
 
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   Advance(1);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_END_TAG, token_.type);
@@ -293,12 +293,12 @@ TEST_F(GumboTokenizerTest, ScriptEscapedEnd) {
   EXPECT_EQ(GUMBO_TAG_TITLE, token_.v.start_tag.tag);
 
   gumbo_tokenizer_set_state(&parser_, GUMBO_LEX_SCRIPT_ESCAPED);
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ('x', token_.v.character);
 
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_END_TAG, token_.type);
   EXPECT_EQ(GUMBO_TAG_TITLE, token_.v.end_tag);
@@ -316,42 +316,42 @@ TEST_F(GumboTokenizerTest, ScriptCommentEscaped) {
   EXPECT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ('x', token_.v.character);
 
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_WHITESPACE, token_.type);
   EXPECT_EQ(' ', token_.v.character);
 
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ('<', token_.v.character);
 
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_WHITESPACE, token_.type);
   EXPECT_EQ(' ', token_.v.character);
 
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ('7', token_.v.character);
 
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   Advance(4);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ('<', token_.v.character);
 
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ('/', token_.v.character);
 
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ('d', token_.v.character);
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   Advance(25);
 }
 
@@ -363,23 +363,23 @@ TEST_F(GumboTokenizerTest, ScriptEscapedEmbeddedLessThan) {
   EXPECT_EQ(GUMBO_TAG_SCRIPT, token_.v.start_tag.tag);
 
   gumbo_tokenizer_set_state(&parser_, GUMBO_LEX_SCRIPT);
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   Advance(14);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ('x', token_.v.character);
 
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ('<', token_.v.character);
 
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ('7', token_.v.character);
 
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   Advance(8);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_END_TAG, token_.type);
@@ -396,17 +396,17 @@ TEST_F(GumboTokenizerTest, ScriptHasTagEmbedded) {
   EXPECT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ('<', token_.v.character);
 
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ('/', token_.v.character);
 
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ('d', token_.v.character);
 
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ('i', token_.v.character);
@@ -423,33 +423,51 @@ TEST_F(GumboTokenizerTest, ScriptDoubleEscaped) {
   EXPECT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ('<', token_.v.character);
 
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ('s', token_.v.character);
 
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ('C', token_.v.character);
 
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   Advance(20);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ('-', token_.v.character);
 
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ('-', token_.v.character);
 
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ('>', token_.v.character);
 }
 
+TEST_F(GumboTokenizerTest, CData) {
+  // SetInput uses strlen and so can't handle nulls.
+  text_ = "<![CDATA[\0filler\0text\0]]>";
+  gumbo_tokenizer_state_destroy(&parser_);
+  gumbo_tokenizer_state_init(
+      &parser_, text_, sizeof("<![CDATA[\0filler\0text\0]]>") - 1);
+  gumbo_tokenizer_set_is_current_node_foreign(&parser_, true);
+
+  EXPECT_TRUE(gumbo_lex(&parser_, &token_));
+  EXPECT_EQ(GUMBO_TOKEN_NULL, token_.type);
+  EXPECT_EQ(0, token_.v.character);
+
+  gumbo_token_destroy(&token_);
+  EXPECT_TRUE(gumbo_lex(&parser_, &token_));
+  EXPECT_EQ(GUMBO_TOKEN_CDATA, token_.type);
+  EXPECT_EQ('f', token_.v.character);
+}
+
 TEST_F(GumboTokenizerTest, StyleHasTagEmbedded) {
   SetInput("<style>/* For <head> */</style>");
   Advance(1);
@@ -460,12 +478,12 @@ TEST_F(GumboTokenizerTest, StyleHasTagEmbedded) {
   EXPECT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ('<', token_.v.character);
 
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ('h', token_.v.character);
 
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ('e', token_.v.character);
@@ -477,7 +495,7 @@ TEST_F(GumboTokenizerTest, PreWithNewlines) {
   ASSERT_EQ(GUMBO_TOKEN_DOCTYPE, token_.type);
   EXPECT_EQ(0, token_.position.offset);
 
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   ASSERT_EQ(GUMBO_TOKEN_START_TAG, token_.type);
   EXPECT_EQ("<pre>", ToString(token_.original_text));
@@ -528,7 +546,7 @@ TEST_F(GumboTokenizerTest, BogusComment1) {
   ASSERT_EQ(GUMBO_TOKEN_COMMENT, token_.type);
   EXPECT_STREQ("?xml is bogus-comment", token_.v.text);
 
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ('T', token_.v.character);
@@ -542,7 +560,7 @@ TEST_F(GumboTokenizerTest, BogusComment2) {
   ASSERT_EQ(GUMBO_TOKEN_COMMENT, token_.type);
   EXPECT_STREQ("#bogus-comment", token_.v.text);
 
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   EXPECT_TRUE(gumbo_lex(&parser_, &token_));
   EXPECT_EQ(GUMBO_TOKEN_EOF, token_.type);
   errors_are_expected_ = true;
@@ -623,13 +641,13 @@ TEST_F(GumboTokenizerTest, MatchedTagPair) {
   EXPECT_EQ(30, data_attr->value_start.column);
   EXPECT_EQ(35, data_attr->value_end.column);
 
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   ASSERT_TRUE(gumbo_lex(&parser_, &token_));
   ASSERT_EQ(GUMBO_TOKEN_CHARACTER, token_.type);
   EXPECT_EQ(35, token_.position.offset);
   EXPECT_EQ('a', token_.v.character);
 
-  gumbo_token_destroy(&parser_, &token_);
+  gumbo_token_destroy(&token_);
   ASSERT_TRUE(gumbo_lex(&parser_, &token_));
   ASSERT_EQ(GUMBO_TOKEN_END_TAG, token_.type);
   EXPECT_EQ(GUMBO_TAG_DIV, token_.v.end_tag);
diff --git a/tests/utf8.cc b/tests/utf8.cc
index 479e4bc8..a98c69c2 100644
--- a/tests/utf8.cc
+++ b/tests/utf8.cc
@@ -556,6 +556,21 @@ TEST_F(Utf8Test, MatchesCaseInsensitive) {
   EXPECT_EQ(-1, utf8iterator_current(&input_));
 }
 
+TEST_F(Utf8Test, MatchFollowedByNullByte) {
+  // Can't use ResetText, as the implicit strlen will choke on the null.
+  text_ = "CDATA\0f";
+  utf8iterator_init(&parser_, text_, 7, &input_);
+
+  EXPECT_TRUE(utf8iterator_maybe_consume_match(
+        &input_, "cdata", sizeof("cdata") - 1, false));
+
+  EXPECT_EQ(0, utf8iterator_current(&input_));
+  EXPECT_EQ('\0', *utf8iterator_get_char_pointer(&input_));
+  utf8iterator_next(&input_);
+  EXPECT_EQ('f', utf8iterator_current(&input_));
+  EXPECT_EQ('f', *utf8iterator_get_char_pointer(&input_));
+}
+
 TEST_F(Utf8Test, MarkReset) {
   ResetText("this is a test");
   Advance(5);
diff --git a/tests/vector.cc b/tests/vector.cc
index b65cd1c1..d1948f18 100644
--- a/tests/vector.cc
+++ b/tests/vector.cc
@@ -26,13 +26,12 @@ namespace {
 
 class GumboVectorTest : public GumboTest {
  protected:
-  GumboVectorTest() : one_(1), two_(2), three_(3),
-      num_allocations_(0), bytes_allocated_(0), num_deallocations_(0) {
-    gumbo_vector_init(&parser_, 2, &vector_);
+  GumboVectorTest() : one_(1), two_(2), three_(3) {
+    gumbo_vector_init(2, &vector_);
   }
 
   ~GumboVectorTest() {
-    gumbo_vector_destroy(&parser_, &vector_);
+    gumbo_vector_destroy(&vector_);
   }
 
   GumboVector vector_;
@@ -41,24 +40,6 @@ class GumboVectorTest : public GumboTest {
   int one_;
   int two_;
   int three_;
-
-  // Counters for testing a custom allocator.
-  int num_allocations_;
-  int bytes_allocated_;
-  int num_deallocations_;
-
-  static void* custom_gumbo_vector_allocator(void* userdata, size_t num_bytes) {
-    GumboVectorTest* test = static_cast<GumboVectorTest*>(userdata);
-    ++test->num_allocations_;
-    test->bytes_allocated_ += num_bytes;
-    return malloc(num_bytes);
-  }
-
-  static void custom_gumbo_vector_deallocator(void* userdata, void* ptr) {
-    GumboVectorTest* test = static_cast<GumboVectorTest*>(userdata);
-    ++test->num_deallocations_;
-    free(ptr);
-  }
 };
 
 TEST_F(GumboVectorTest, Init) {
@@ -67,16 +48,16 @@ TEST_F(GumboVectorTest, Init) {
 }
 
 TEST_F(GumboVectorTest, InitZeroCapacity) {
-  gumbo_vector_destroy(&parser_, &vector_);
-  gumbo_vector_init(&parser_, 0, &vector_);
+  gumbo_vector_destroy(&vector_);
+  gumbo_vector_init(0, &vector_);
 
-  gumbo_vector_add(&parser_, &one_, &vector_);
+  gumbo_vector_add(&one_, &vector_);
   EXPECT_EQ(1, vector_.length);
   EXPECT_EQ(1, *(static_cast<int*>(vector_.data[0])));
 }
 
 TEST_F(GumboVectorTest, Add) {
-  gumbo_vector_add(&parser_, &one_, &vector_);
+  gumbo_vector_add(&one_, &vector_);
   EXPECT_EQ(1, vector_.length);
   EXPECT_EQ(1, *(static_cast<int*>(vector_.data[0])));
   EXPECT_EQ(0, gumbo_vector_index_of(&vector_, &one_));
@@ -84,67 +65,67 @@ TEST_F(GumboVectorTest, Add) {
 }
 
 TEST_F(GumboVectorTest, AddMultiple) {
-  gumbo_vector_add(&parser_, &one_, &vector_);
-  gumbo_vector_add(&parser_, &two_, &vector_);
+  gumbo_vector_add(&one_, &vector_);
+  gumbo_vector_add(&two_, &vector_);
   EXPECT_EQ(2, vector_.length);
   EXPECT_EQ(2, *(static_cast<int*>(vector_.data[1])));
   EXPECT_EQ(1, gumbo_vector_index_of(&vector_, &two_));
 }
 
 TEST_F(GumboVectorTest, Realloc) {
-  gumbo_vector_add(&parser_, &one_, &vector_);
-  gumbo_vector_add(&parser_, &two_, &vector_);
-  gumbo_vector_add(&parser_, &three_, &vector_);
+  gumbo_vector_add(&one_, &vector_);
+  gumbo_vector_add(&two_, &vector_);
+  gumbo_vector_add(&three_, &vector_);
   EXPECT_EQ(3, vector_.length);
   EXPECT_EQ(4, vector_.capacity);
   EXPECT_EQ(3, *(static_cast<int*>(vector_.data[2])));
 }
 
 TEST_F(GumboVectorTest, Pop) {
-  gumbo_vector_add(&parser_, &one_, &vector_);
-  int result = *static_cast<int*>(gumbo_vector_pop(&parser_, &vector_));
+  gumbo_vector_add(&one_, &vector_);
+  int result = *static_cast<int*>(gumbo_vector_pop(&vector_));
   EXPECT_EQ(1, result);
   EXPECT_EQ(0, vector_.length);
 }
 
 TEST_F(GumboVectorTest, PopEmpty) {
-  EXPECT_EQ(NULL, gumbo_vector_pop(&parser_, &vector_));
+  EXPECT_EQ(NULL, gumbo_vector_pop(&vector_));
 }
 
 TEST_F(GumboVectorTest, InsertAtFirst) {
-  gumbo_vector_add(&parser_, &one_, &vector_);
-  gumbo_vector_add(&parser_, &two_, &vector_);
-  gumbo_vector_insert_at(&parser_, &three_, 0, &vector_);
+  gumbo_vector_add(&one_, &vector_);
+  gumbo_vector_add(&two_, &vector_);
+  gumbo_vector_insert_at(&three_, 0, &vector_);
   EXPECT_EQ(3, vector_.length);
   int result = *static_cast<int*>(vector_.data[0]);
   EXPECT_EQ(3, result);
 }
 
 TEST_F(GumboVectorTest, InsertAtLast) {
-  gumbo_vector_add(&parser_, &one_, &vector_);
-  gumbo_vector_add(&parser_, &two_, &vector_);
-  gumbo_vector_insert_at(&parser_, &three_, 2, &vector_);
+  gumbo_vector_add(&one_, &vector_);
+  gumbo_vector_add(&two_, &vector_);
+  gumbo_vector_insert_at(&three_, 2, &vector_);
   EXPECT_EQ(3, vector_.length);
   int result = *static_cast<int*>(vector_.data[2]);
   EXPECT_EQ(3, result);
 }
 
 TEST_F(GumboVectorTest, Remove) {
-  gumbo_vector_add(&parser_, &one_, &vector_);
-  gumbo_vector_add(&parser_, &two_, &vector_);
-  gumbo_vector_add(&parser_, &three_, &vector_);
-  gumbo_vector_remove(&parser_, &two_, &vector_);
+  gumbo_vector_add(&one_, &vector_);
+  gumbo_vector_add(&two_, &vector_);
+  gumbo_vector_add(&three_, &vector_);
+  gumbo_vector_remove(&two_, &vector_);
   EXPECT_EQ(2, vector_.length);
   int three = *static_cast<int*>(vector_.data[1]);
   EXPECT_EQ(3, three);
 }
 
 TEST_F(GumboVectorTest, RemoveAt) {
-  gumbo_vector_add(&parser_, &one_, &vector_);
-  gumbo_vector_add(&parser_, &two_, &vector_);
-  gumbo_vector_add(&parser_, &three_, &vector_);
+  gumbo_vector_add(&one_, &vector_);
+  gumbo_vector_add(&two_, &vector_);
+  gumbo_vector_add(&three_, &vector_);
   int result = *static_cast<int*>(
-      gumbo_vector_remove_at(&parser_, 1, &vector_));
+      gumbo_vector_remove_at(1, &vector_));
   EXPECT_EQ(2, result);
   EXPECT_EQ(2, vector_.length);
   int three = *static_cast<int*>(vector_.data[1]);