nokogumbo 1.3.0 → 1.5.0

data/gumbo-parser/src/char_ref.h

@@ -49,10 +49,9 @@ typedef struct {
 // errors to the GumboParser's errors vector, if the spec calls for it.  Pass a
 // space for the "additional allowed char" when the spec says "with no
 // additional allowed char".  Returns false on parse error, true otherwise.
-bool consume_char_ref(
-    struct GumboInternalParser* parser, struct GumboInternalUtf8Iterator* input,
-    int additional_allowed_char, bool is_in_attribute,
-    OneOrTwoCodepoints* output);
+bool consume_char_ref(struct GumboInternalParser* parser,
+    struct GumboInternalUtf8Iterator* input, int additional_allowed_char,
+    bool is_in_attribute, OneOrTwoCodepoints* output);
 
 #ifdef __cplusplus
 }

data/gumbo-parser/src/char_ref.rl

@@ -2464,7 +2464,9 @@ valid_named_ref := |*
 *|;
 }%%
 
-%% write data;
+// clang-format off
+%% write data noerror nofinal;
+// clang-format on
 
 static bool consume_named_ref(
     struct GumboInternalParser* parser, Utf8Iterator* input, bool is_in_attribute,
@@ -2477,13 +2479,16 @@ static bool consume_named_ref(
   const char *ts, *start;
   int cs, act;
 
+  // clang-format off
   %% write init;
   // Avoid unused variable warnings.
   (void) act;
   (void) ts;
+  (void) char_ref_en_valid_named_ref;
 
   start = p;
   %% write exec;
+  // clang-format on
 
   if (cs >= %%{ write first_final; }%%) {
     assert(output->first != kGumboNoChar);

data/gumbo-parser/src/error.c

@@ -27,18 +27,17 @@
 #include "util.h"
 #include "vector.h"
 
-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(
+    GumboParser* parser, GumboStringBuffer* output, const char* format, ...) {
   va_list args;
-  va_start(args, format);
   int remaining_capacity = output->capacity - output->length;
-  int bytes_written = vsnprintf(output->data + output->length,
-                                remaining_capacity, format, args);
+  va_start(args, format);
+  int bytes_written = vsnprintf(
+      output->data + output->length, remaining_capacity, format, args);
+  va_end(args);
 #ifdef _MSC_VER
   if (bytes_written == -1) {
     // vsnprintf returns -1 on MSVC++ if there's not enough capacity, instead of
@@ -47,15 +46,15 @@ static int print_message(GumboParser* parser, GumboStringBuffer* output,
     // we retry (letting it fail and returning 0 if it doesn't), since there's
     // no way to smartly resize the buffer.
     gumbo_string_buffer_reserve(parser, output->capacity * 2, output);
-    int result = vsnprintf(output->data + output->length,
-                           remaining_capacity, format, args);
+    va_start(args, format);
+    int result = vsnprintf(
+        output->data + output->length, remaining_capacity, format, args);
     va_end(args);
     return result == -1 ? 0 : result;
   }
 #else
   // -1 in standard C99 indicates an encoding error.  Return 0 and do nothing.
   if (bytes_written == -1) {
-    va_end(args);
     return 0;
   }
 #endif
@@ -64,19 +63,19 @@ static int print_message(GumboParser* parser, GumboStringBuffer* output,
     gumbo_string_buffer_reserve(
         parser, output->capacity + bytes_written, output);
     remaining_capacity = output->capacity - output->length;
-    bytes_written = vsnprintf(output->data + output->length,
-                              remaining_capacity, format, args);
+    va_start(args, format);
+    bytes_written = vsnprintf(
+        output->data + output->length, remaining_capacity, format, args);
+    va_end(args);
   }
   output->length += bytes_written;
-  va_end(args);
   return bytes_written;
 }
 
-static void print_tag_stack(
-    GumboParser* parser, const GumboParserError* error,
+static void print_tag_stack(GumboParser* parser, const GumboParserError* error,
     GumboStringBuffer* output) {
   print_message(parser, output, "  Currently open tags: ");
-  for (int i = 0; i < error->tag_stack.length; ++i) {
+  for (unsigned int i = 0; i < error->tag_stack.length; ++i) {
     if (i) {
       print_message(parser, output, ", ");
     }
@@ -87,12 +86,11 @@ static void print_tag_stack(
 }
 
 static void handle_parser_error(GumboParser* parser,
-                                const GumboParserError* error,
-                                GumboStringBuffer* output) {
+    const GumboParserError* error, GumboStringBuffer* output) {
   if (error->parser_state == GUMBO_INSERTION_MODE_INITIAL &&
       error->input_type != GUMBO_TOKEN_DOCTYPE) {
-    print_message(parser, output,
-                  "The doctype must be the first token in the document");
+    print_message(
+        parser, output, "The doctype must be the first token in the document");
     return;
   }
 
@@ -106,6 +104,7 @@ static void handle_parser_error(GumboParser* parser,
       // But just in case...
       print_message(parser, 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");
@@ -150,13 +149,14 @@ static const char* find_last_newline(
 static const char* find_next_newline(
     const char* original_text, const char* error_location) {
   const char* c = error_location;
-  for (; *c && *c != '\n'; ++c);
+  for (; *c && *c != '\n'; ++c)
+    ;
   return c;
 }
 
 GumboError* gumbo_add_error(GumboParser* parser) {
   int max_errors = parser->_options->max_errors;
-  if (max_errors >= 0 && parser->_output->errors.length >= max_errors) {
+  if (max_errors >= 0 && parser->_output->errors.length >= (unsigned int) max_errors) {
     return NULL;
   }
   GumboError* error = gumbo_parser_allocate(parser, sizeof(GumboError));
@@ -166,50 +166,52 @@ GumboError* gumbo_add_error(GumboParser* parser) {
 
 void gumbo_error_to_string(
     GumboParser* parser, const GumboError* error, GumboStringBuffer* output) {
-  print_message(parser, output, "@%d:%d: ",
-                error->position.line, error->position.column);
+  print_message(
+      parser, 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",
-               error->v.codepoint);
+      print_message(
+          parser, output, "Invalid UTF8 character 0x%x", error->v.codepoint);
       break;
     case GUMBO_ERR_UTF8_TRUNCATED:
       print_message(parser, output,
-               "Input stream ends with a truncated UTF8 character 0x%x",
-               error->v.codepoint);
+          "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,
-               "No digits after &# in numeric character reference");
+      print_message(
+          parser, output, "No digits after &# in numeric character reference");
       break;
     case GUMBO_ERR_NUMERIC_CHAR_REF_WITHOUT_SEMICOLON:
       print_message(parser, output,
-               "The numeric character reference &#%d should be followed "
-               "by a semicolon", error->v.codepoint);
+          "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,
-               "The numeric character reference &#%d; encodes an invalid "
-               "unicode codepoint", error->v.codepoint);
+          "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,
-               "The named character reference &%.*s should be followed by a "
-               "semicolon", (int) error->v.text.length, error->v.text.data);
+          "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,
-               "The named character reference &%.*s; is not a valid entity name",
-               (int) error->v.text.length, error->v.text.data);
+          "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,
-               "Attribute %s occurs multiple times, at positions %d and %d",
-               error->v.duplicate_attr.name,
-               error->v.duplicate_attr.original_index,
-               error->v.duplicate_attr.new_index);
+          "Attribute %s occurs multiple times, at positions %d and %d",
+          error->v.duplicate_attr.name, error->v.duplicate_attr.original_index,
+          error->v.duplicate_attr.new_index);
       break;
     case GUMBO_ERR_PARSER:
     case GUMBO_ERR_UNACKNOWLEDGED_SELF_CLOSING_TAG:
@@ -217,21 +219,19 @@ void gumbo_error_to_string(
       break;
     default:
       print_message(parser, output,
-               "Tokenizer error with an unimplemented error message");
+          "Tokenizer error with an unimplemented error message");
       break;
   }
   gumbo_string_buffer_append_codepoint(parser, '.', output);
 }
 
-void gumbo_caret_diagnostic_to_string(
-    GumboParser* parser, const GumboError* error,
-    const char* source_text, GumboStringBuffer* output) {
+void gumbo_caret_diagnostic_to_string(GumboParser* parser,
+    const GumboError* error, const char* source_text,
+    GumboStringBuffer* output) {
   gumbo_error_to_string(parser, error, output);
 
-  const char* line_start =
-      find_last_newline(source_text, error->original_text);
-  const char* line_end =
-      find_next_newline(source_text, error->original_text);
+  const char* line_start = find_last_newline(source_text, error->original_text);
+  const char* line_end = find_next_newline(source_text, error->original_text);
   GumboStringPiece original_line;
   original_line.data = line_start;
   original_line.length = line_end - line_start;
@@ -272,7 +272,7 @@ void gumbo_init_errors(GumboParser* parser) {
 }
 
 void gumbo_destroy_errors(GumboParser* parser) {
-  for (int i = 0; i < parser->_output->errors.length; ++i) {
+  for (unsigned int i = 0; i < parser->_output->errors.length; ++i) {
     gumbo_error_destroy(parser, parser->_output->errors.data[i]);
   }
   gumbo_vector_destroy(parser, &parser->_output->errors);

data/gumbo-parser/src/error.h

@@ -201,24 +201,22 @@ void gumbo_error_destroy(struct GumboInternalParser* parser, GumboError* error);
 // 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);
+void gumbo_error_to_string(struct GumboInternalParser* parser,
+    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,
-    const char* source_text, GumboStringBuffer* output);
+void gumbo_caret_diagnostic_to_string(struct GumboInternalParser* parser,
+    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);
+void gumbo_print_caret_diagnostic(struct GumboInternalParser* parser,
+    const GumboError* error, const char* source_text);
 
 #ifdef __cplusplus
 }

data/gumbo-parser/src/gumbo.h

@@ -76,7 +76,6 @@ typedef struct {
  */
 extern const GumboSourcePosition kGumboEmptySourcePosition;
 
-
 /**
  * A struct representing a string or part of a string.  Strings within the
  * parser are represented by a char* and a length; the char* points into
@@ -111,7 +110,6 @@ bool gumbo_string_equals(
 bool gumbo_string_equals_ignore_case(
     const GumboStringPiece* str1, const GumboStringPiece* str2);
 
-
 /**
  * A simple vector implementation.  This stores a pointer to a data array and a
  * length.  All elements are stored as void*; client code must cast to the
@@ -141,8 +139,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);
 
 /**
  * An enum for all the tags defined in the HTML5 standard.  These correspond to
@@ -157,172 +154,10 @@ 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,
-  // Used for all tags that don't have special handling in HTML.
+// Load all the tags from an external source, generated from tag.in.
+#include "tag_enum.h"
+  // Used for all tags that don't have special handling in HTML.  Add new tags
+  // to the end of tag.in so as to preserve backwards-compatibility.
   GUMBO_TAG_UNKNOWN,
   // A marker value to indicate the end of the enum, for iterating over it.
   // Also used as the terminator for varargs functions that take tags.
@@ -364,9 +199,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, unsigned int length);
 
 /**
  * Attribute namespaces.
@@ -461,10 +297,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;
 
 /**
@@ -473,7 +315,9 @@ typedef enum {
  */
 typedef struct GumboInternalNode GumboNode;
 
-/** http://www.whatwg.org/specs/web-apps/current-work/complete/dom.html#quirks-mode */
+/**
+ * http://www.whatwg.org/specs/web-apps/current-work/complete/dom.html#quirks-mode
+ */
 typedef enum {
   GUMBO_DOCTYPE_NO_QUIRKS,
   GUMBO_DOCTYPE_QUIRKS,
@@ -571,7 +415,6 @@ typedef enum {
   GUMBO_INSERTION_FOSTER_PARENTED = 1 << 10,
 } GumboParseFlags;
 
-
 /**
  * Information specific to document nodes.
  */
@@ -690,9 +533,9 @@ struct GumboInternalNode {
 
   /** The actual node data. */
   union {
-    GumboDocument document;      // For GUMBO_NODE_DOCUMENT.
-    GumboElement element;        // For GUMBO_NODE_ELEMENT.
-    GumboText text;              // For everything else.
+    GumboDocument document;  // For GUMBO_NODE_DOCUMENT.
+    GumboElement element;    // For GUMBO_NODE_ELEMENT.
+    GumboText text;          // For everything else.
   } v;
 };
 
@@ -750,6 +593,29 @@ typedef struct GumboInternalOptions {
    * Default: -1
    */
   int max_errors;
+
+  /**
+   * The fragment context for parsing:
+   * https://html.spec.whatwg.org/multipage/syntax.html#parsing-html-fragments
+   *
+   * If GUMBO_TAG_LAST is passed here, it is assumed to be "no fragment", i.e.
+   * the regular parsing algorithm.  Otherwise, pass the tag enum for the
+   * intended parent of the parsed fragment.  We use just the tag enum rather
+   * than a full node because that's enough to set all the parsing context we
+   * need, and it provides some additional flexibility for client code to act as
+   * if parsing a fragment even when a full HTML tree isn't available.
+   *
+   * Default: GUMBO_TAG_LAST
+   */
+  GumboTag fragment_context;
+
+  /**
+   * The namespace for the fragment context.  This lets client code
+   * differentiate between, say, parsing a <title> tag in SVG vs. parsing it in
+   * HTML.
+   * Default: GUMBO_NAMESPACE_HTML
+   */
+  GumboNamespaceEnum fragment_namespace;
 } GumboOptions;
 
 /** Default options struct; use this with gumbo_parse_with_options. */
@@ -796,9 +662,7 @@ GumboOutput* gumbo_parse_with_options(
     const GumboOptions* options, const char* buffer, size_t buffer_length);
 
 /** Release the memory used for the parse tree & parse errors. */
-void gumbo_destroy_output(
-    const GumboOptions* options, GumboOutput* output);
-
+void gumbo_destroy_output(const GumboOptions* options, GumboOutput* output);
 
 #ifdef __cplusplus
 }