nokogiri 1.11.7 → 1.12.1

data/gumbo-parser/src/error.h

@@ -0,0 +1,148 @@
+#ifndef GUMBO_ERROR_H_
+#define GUMBO_ERROR_H_
+
+#include <stdint.h>
+
+#include "gumbo.h"
+#include "insertion_mode.h"
+#include "string_buffer.h"
+#include "token_type.h"
+#include "tokenizer_states.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct GumboInternalParser;
+
+typedef enum {
+  // Defined errors.
+  // https://html.spec.whatwg.org/multipage/parsing.html#parse-errors
+  GUMBO_ERR_ABRUPT_CLOSING_OF_EMPTY_COMMENT,
+  GUMBO_ERR_ABRUPT_DOCTYPE_PUBLIC_IDENTIFIER,
+  GUMBO_ERR_ABRUPT_DOCTYPE_SYSTEM_IDENTIFIER,
+  GUMBO_ERR_ABSENCE_OF_DIGITS_IN_NUMERIC_CHARACTER_REFERENCE,
+  GUMBO_ERR_CDATA_IN_HTML_CONTENT,
+  GUMBO_ERR_CHARACTER_REFERENCE_OUTSIDE_UNICODE_RANGE,
+  GUMBO_ERR_CONTROL_CHARACTER_IN_INPUT_STREAM,
+  GUMBO_ERR_CONTROL_CHARACTER_REFERENCE,
+  GUMBO_ERR_END_TAG_WITH_ATTRIBUTES,
+  GUMBO_ERR_DUPLICATE_ATTRIBUTE,
+  GUMBO_ERR_END_TAG_WITH_TRAILING_SOLIDUS,
+  GUMBO_ERR_EOF_BEFORE_TAG_NAME,
+  GUMBO_ERR_EOF_IN_CDATA,
+  GUMBO_ERR_EOF_IN_COMMENT,
+  GUMBO_ERR_EOF_IN_DOCTYPE,
+  GUMBO_ERR_EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT,
+  GUMBO_ERR_EOF_IN_TAG,
+  GUMBO_ERR_INCORRECTLY_CLOSED_COMMENT,
+  GUMBO_ERR_INCORRECTLY_OPENED_COMMENT,
+  GUMBO_ERR_INVALID_CHARACTER_SEQUENCE_AFTER_DOCTYPE_NAME,
+  GUMBO_ERR_INVALID_FIRST_CHARACTER_OF_TAG_NAME,
+  GUMBO_ERR_MISSING_ATTRIBUTE_VALUE,
+  GUMBO_ERR_MISSING_DOCTYPE_NAME,
+  GUMBO_ERR_MISSING_DOCTYPE_PUBLIC_IDENTIFIER,
+  GUMBO_ERR_MISSING_DOCTYPE_SYSTEM_IDENTIFIER,
+  GUMBO_ERR_MISSING_END_TAG_NAME,
+  GUMBO_ERR_MISSING_QUOTE_BEFORE_DOCTYPE_PUBLIC_IDENTIFIER,
+  GUMBO_ERR_MISSING_QUOTE_BEFORE_DOCTYPE_SYSTEM_IDENTIFIER,
+  GUMBO_ERR_MISSING_SEMICOLON_AFTER_CHARACTER_REFERENCE,
+  GUMBO_ERR_MISSING_WHITESPACE_AFTER_DOCTYPE_PUBLIC_KEYWORD,
+  GUMBO_ERR_MISSING_WHITESPACE_AFTER_DOCTYPE_SYSTEM_KEYWORD,
+  GUMBO_ERR_MISSING_WHITESPACE_BEFORE_DOCTYPE_NAME,
+  GUMBO_ERR_MISSING_WHITESPACE_BETWEEN_ATTRIBUTES,
+  GUMBO_ERR_MISSING_WHITESPACE_BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS,
+  GUMBO_ERR_NESTED_COMMENT,
+  GUMBO_ERR_NONCHARACTER_CHARACTER_REFERENCE,
+  GUMBO_ERR_NONCHARACTER_IN_INPUT_STREAM,
+  GUMBO_ERR_NON_VOID_HTML_ELEMENT_START_TAG_WITH_TRAILING_SOLIDUS,
+  GUMBO_ERR_NULL_CHARACTER_REFERENCE,
+  GUMBO_ERR_SURROGATE_CHARACTER_REFERENCE,
+  GUMBO_ERR_SURROGATE_IN_INPUT_STREAM,
+  GUMBO_ERR_UNEXPECTED_CHARACTER_AFTER_DOCTYPE_SYSTEM_IDENTIFIER,
+  GUMBO_ERR_UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME,
+  GUMBO_ERR_UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE,
+  GUMBO_ERR_UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME,
+  GUMBO_ERR_UNEXPECTED_NULL_CHARACTER,
+  GUMBO_ERR_UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME,
+  GUMBO_ERR_UNEXPECTED_SOLIDUS_IN_TAG,
+  GUMBO_ERR_UNKNOWN_NAMED_CHARACTER_REFERENCE,
+
+  // Encoding errors.
+  GUMBO_ERR_UTF8_INVALID,
+  GUMBO_ERR_UTF8_TRUNCATED,
+
+  // Generic parser error.
+  GUMBO_ERR_PARSER,
+} GumboErrorType;
+
+// Additional data for tokenizer errors.
+// This records the current state and codepoint encountered - this is usually
+// enough to reconstruct what went wrong and provide a friendly error message.
+typedef struct GumboInternalTokenizerError {
+  // The bad codepoint encountered.
+  int codepoint;
+
+  // The state that the tokenizer was in at the time.
+  GumboTokenizerEnum state;
+} GumboTokenizerError;
+
+// Additional data for parse errors.
+typedef struct GumboInternalParserError {
+  // The type of input token that resulted in this error.
+  GumboTokenType input_type;
+
+  // The HTML tag of the input token. TAG_UNKNOWN if this was not a tag token.
+  GumboTag input_tag;
+
+  // The insertion mode that the parser was in at the time.
+  GumboInsertionMode parser_state;
+
+  // The tag stack at the point of the error. Note that this is an GumboVector
+  // of GumboTag's *stored by value* - cast the void* to an GumboTag directly to
+  // get at the tag.
+  GumboVector /* GumboTag */ tag_stack;
+} GumboParserError;
+
+// The overall error struct representing an error in decoding/tokenizing/parsing
+// the HTML. This contains an enumerated type flag, a source position, and then
+// a union of fields containing data specific to the error.
+struct GumboInternalError {
+  // The type of error.
+  GumboErrorType type;
+
+  // The position within the source file where the error occurred.
+  GumboSourcePosition position;
+
+  // The piece of text that caused the error.
+  GumboStringPiece original_text;
+
+  // Type-specific error information.
+  union {
+    // Tokenizer errors.
+    GumboTokenizerError tokenizer;
+
+    // Parser errors.
+    GumboParserError parser;
+  } v;
+};
+
+// Adds a new error to the parser's error list, and returns a pointer to it so
+// that clients can fill out the rest of its fields. May return NULL if we're
+// already over the max_errors field specified in GumboOptions.
+GumboError* gumbo_add_error(struct GumboInternalParser* parser);
+
+// Initializes the errors vector in the parser.
+void gumbo_init_errors(struct GumboInternalParser* errors);
+
+// Frees all the errors in the 'errors_' field of the parser.
+void gumbo_destroy_errors(struct GumboInternalParser* errors);
+
+// Frees the memory used for a single GumboError.
+void gumbo_error_destroy(GumboError* error);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GUMBO_ERROR_H_

data/gumbo-parser/src/foreign_attrs.c

@@ -0,0 +1,104 @@
+/* ANSI-C code produced by gperf version 3.1 */
+/* Command-line: gperf -m100 -n lib/foreign_attrs.gperf  */
+/* Computed positions: -k'2,8' */
+/* Filtered by: mk/gperf-filter.sed */
+
+#include "replacement.h"
+#include "macros.h"
+#include <string.h>
+
+#define TOTAL_KEYWORDS 11
+#define MIN_WORD_LENGTH 5
+#define MAX_WORD_LENGTH 13
+#define MIN_HASH_VALUE 0
+#define MAX_HASH_VALUE 10
+/* maximum key range = 11, duplicates = 0 */
+
+static inline unsigned int
+hash (register const char *str, register size_t len)
+{
+  static const unsigned char asso_values[] =
+    {
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11,  2,
+      11, 10, 11,  9,  7,  6, 11, 11,  1,  0,
+      11,  5, 11, 11,  4, 11, 11, 11, 11, 11,
+      11,  3, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11
+    };
+  register unsigned int hval = 0;
+
+  switch (len)
+    {
+      default:
+        hval += asso_values[(unsigned char)str[7]];
+      /*FALLTHROUGH*/
+      case 7:
+      case 6:
+      case 5:
+      case 4:
+      case 3:
+      case 2:
+        hval += asso_values[(unsigned char)str[1]];
+        break;
+    }
+  return hval;
+}
+
+const ForeignAttrReplacement *
+gumbo_get_foreign_attr_replacement (register const char *str, register size_t len)
+{
+  static const unsigned char lengthtable[] =
+    {
+       5, 11,  9, 13, 10, 10, 10, 11, 10,  8,  8
+    };
+  static const ForeignAttrReplacement wordlist[] =
+    {
+      {"xmlns", "xmlns", GUMBO_ATTR_NAMESPACE_XMLNS},
+      {"xmlns:xlink", "xlink", GUMBO_ATTR_NAMESPACE_XMLNS},
+      {"xml:space", "space", GUMBO_ATTR_NAMESPACE_XML},
+      {"xlink:actuate", "actuate", GUMBO_ATTR_NAMESPACE_XLINK},
+      {"xlink:type", "type", GUMBO_ATTR_NAMESPACE_XLINK},
+      {"xlink:href", "href", GUMBO_ATTR_NAMESPACE_XLINK},
+      {"xlink:role", "role", GUMBO_ATTR_NAMESPACE_XLINK},
+      {"xlink:title", "title", GUMBO_ATTR_NAMESPACE_XLINK},
+      {"xlink:show", "show", GUMBO_ATTR_NAMESPACE_XLINK},
+      {"xml:lang", "lang", GUMBO_ATTR_NAMESPACE_XML},
+      {"xml:base", "base", GUMBO_ATTR_NAMESPACE_XML}
+    };
+
+  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
+    {
+      register unsigned int key = hash (str, len);
+
+      if (key <= MAX_HASH_VALUE)
+        if (len == lengthtable[key])
+          {
+            register const char *s = wordlist[key].from;
+
+            if (s && *str == *s && !memcmp (str + 1, s + 1, len - 1))
+              return &wordlist[key];
+          }
+    }
+  return 0;
+}

data/gumbo-parser/src/foreign_attrs.gperf

@@ -0,0 +1,27 @@
+%{
+#include "replacement.h"
+#include "macros.h"
+%}
+
+%struct-type
+%omit-struct-type
+%compare-lengths
+%readonly-tables
+%null-strings
+%includes
+%define lookup-function-name gumbo_get_foreign_attr_replacement
+%define slot-name from
+ForeignAttrReplacement;
+
+%%
+"xlink:actuate", "actuate", GUMBO_ATTR_NAMESPACE_XLINK
+"xlink:href", "href", GUMBO_ATTR_NAMESPACE_XLINK
+"xlink:role", "role", GUMBO_ATTR_NAMESPACE_XLINK
+"xlink:show", "show", GUMBO_ATTR_NAMESPACE_XLINK
+"xlink:title", "title", GUMBO_ATTR_NAMESPACE_XLINK
+"xlink:type", "type", GUMBO_ATTR_NAMESPACE_XLINK
+"xml:base", "base", GUMBO_ATTR_NAMESPACE_XML
+"xml:lang", "lang", GUMBO_ATTR_NAMESPACE_XML
+"xml:space", "space", GUMBO_ATTR_NAMESPACE_XML
+"xmlns", "xmlns", GUMBO_ATTR_NAMESPACE_XMLNS
+"xmlns:xlink", "xlink", GUMBO_ATTR_NAMESPACE_XMLNS

data/gumbo-parser/src/gumbo.h

@@ -0,0 +1,943 @@
+// Copyright 2010 Google Inc.
+// Copyright 2018 Craig Barnes.
+// Licensed under the Apache License, version 2.0.
+
+// We use Gumbo as a prefix for types, gumbo_ as a prefix for functions,
+// GUMBO_ as a prefix for enum constants and kGumbo as a prefix for
+// static constants
+
+/**
+ * @file
+ * @mainpage Gumbo HTML Parser
+ *
+ * This provides a conformant, no-dependencies implementation of the
+ * [HTML5] parsing algorithm. It supports only UTF-8 -- if you need
+ * to parse a different encoding, run a preprocessing step to convert
+ * to UTF-8. It returns a parse tree made of the structs in this file.
+ *
+ * Example:
+ * @code
+ *    GumboOutput* output = gumbo_parse(input);
+ *    do_something_with_doctype(output->document);
+ *    do_something_with_html_tree(output->root);
+ *    gumbo_destroy_output(output);
+ * @endcode
+ *
+ * [HTML5]: https://html.spec.whatwg.org/multipage/
+ */
+
+#ifndef GUMBO_H
+#define GUMBO_H
+
+#include <stdbool.h>
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * A struct representing a character position within the original text
+ * buffer. Line and column numbers are 1-based and offsets are 0-based,
+ * which matches how most editors and command-line tools work.
+ */
+typedef struct {
+  size_t line;
+  size_t column;
+  size_t offset;
+} GumboSourcePosition;
+
+/**
+ * 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 an existing data buffer owned by some other code (often
+ * the original input). `GumboStringPiece`s are assumed (by convention)
+ * to be immutable, because they may share data. Clients should assume
+ * that it is not NUL-terminated and should always use explicit lengths
+ * when manipulating them.
+ */
+typedef struct {
+  /** A pointer to the beginning of the string. `NULL` if `length == 0`. */
+  const char* data;
+
+  /** The length of the string fragment, in bytes (may be zero). */
+  size_t length;
+} GumboStringPiece;
+
+#define GUMBO_EMPTY_STRING_INIT { .data = NULL, .length = 0 }
+/** A constant to represent a 0-length null string. */
+#define kGumboEmptyString (const GumboStringPiece)GUMBO_EMPTY_STRING_INIT
+
+/**
+ * Compares two `GumboStringPiece`s, and returns `true` if they're
+ * equal or `false` otherwise.
+ */
+bool gumbo_string_equals (
+  const GumboStringPiece* str1,
+  const GumboStringPiece* str2
+);
+
+/**
+ * Compares two `GumboStringPiece`s, ignoring case, and returns `true`
+ * if they're equal or `false` otherwise.
+ */
+bool gumbo_string_equals_ignore_case (
+  const GumboStringPiece* str1,
+  const GumboStringPiece* str2
+);
+
+/**
+ * Check if the first `GumboStringPiece` is a prefix of the second, ignoring
+ * case.
+ */
+bool gumbo_string_prefix_ignore_case (
+  const GumboStringPiece* prefix,
+  const GumboStringPiece* str
+);
+
+/**
+ * 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 appropriate type. Overflows upon addition result in
+ * reallocation of the data array, with the size doubling to maintain
+ * `O(1)` amortized cost. There is no removal function, as this isn't
+ * needed for any of the operations within this library. Iteration can
+ * be done through inspecting the structure directly in a `for` loop.
+ */
+typedef struct {
+  /**
+   * Data elements. This points to a dynamically-allocated array of
+   * `capacity` elements, each a `void*` to the element itself.
+   */
+  void** data;
+
+  /** Number of elements currently in the vector. */
+  unsigned int length;
+
+  /** Current array capacity. */
+  unsigned int capacity;
+} GumboVector;
+
+# define GUMBO_EMPTY_VECTOR_INIT { .data = NULL, .length = 0, .capacity = 0 }
+/** An empty (0-length, 0-capacity) `GumboVector`. */
+#define kGumboEmptyVector (const GumboVector)GUMBO_EMPTY_VECTOR_INIT
+
+/**
+ * Returns the first index at which an element appears in this vector
+ * (testing by pointer equality), or `-1` if it never does.
+ */
+int gumbo_vector_index_of(GumboVector* vector, const void* element);
+
+/**
+ * An `enum` for all the tags defined in the HTML5 standard. These
+ * correspond to the tag names themselves. Enum constants exist only
+ * for tags that appear in the spec itself (or for tags with special
+ * handling in the SVG and MathML namespaces). Any other tags appear
+ * as `GUMBO_TAG_UNKNOWN` and the actual tag name can be obtained
+ * through `original_tag`.
+ *
+ * This is mostly for API convenience, so that clients of this library
+ * don't need to perform a `strcasecmp` to find the normalized tag
+ * name. It also has efficiency benefits, by letting the parser work
+ * with enums instead of strings.
+ */
+typedef enum {
+  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_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,
+  GUMBO_TAG_DIALOG,
+  // 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.
+  GUMBO_TAG_LAST,
+} GumboTag;
+
+/**
+ * Returns the normalized (all lower case) tag name for a `GumboTag` enum. The
+ * return value is static data owned by the library.
+ */
+const char* gumbo_normalized_tagname(GumboTag tag);
+
+/**
+ * Extracts the tag name from the `original_text` field of an element
+ * or token by stripping off `</>` characters and attributes and
+ * adjusting the passed-in `GumboStringPiece` appropriately. The tag
+ * name is in the original case and shares a buffer with the original
+ * text, to simplify memory management. Behavior is undefined if a
+ * string piece that doesn't represent an HTML tag (`<tagname>` or
+ * `</tagname>`) is passed in. If the string piece is completely
+ * empty (`NULL` data pointer), then this function will exit
+ * successfully as a no-op.
+ */
+void gumbo_tag_from_original_text(GumboStringPiece* text);
+
+/**
+ * Fixes the case of SVG elements that are not all lowercase. This is
+ * not done at parse time because there's no place to store a mutated
+ * tag name. `tag_name` is an enum (which will be `TAG_UNKNOWN` for most
+ * SVG tags without special handling), while `original_tag_name` is a
+ * pointer into the original buffer. Instead, we provide this helper
+ * function that clients can use to rename SVG tags as appropriate.
+ * Returns the case-normalized SVG tagname if a replacement is found, or
+ * `NULL` if no normalization is called for. The return value is static
+ * data and owned by the library.
+ *
+ * @see https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inforeign
+ */
+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.
+ */
+GumboTag gumbo_tagn_enum(const char* tagname, size_t length);
+
+/**
+ * Attribute namespaces.
+ * HTML includes special handling for XLink, XML, and XMLNS namespaces
+ * on attributes. Everything else goes in the generic "NONE" namespace.
+ */
+typedef enum {
+  GUMBO_ATTR_NAMESPACE_NONE,
+  GUMBO_ATTR_NAMESPACE_XLINK,
+  GUMBO_ATTR_NAMESPACE_XML,
+  GUMBO_ATTR_NAMESPACE_XMLNS,
+} GumboAttributeNamespaceEnum;
+
+/**
+ * A struct representing a single attribute on a HTML tag. This is a
+ * name-value pair, but also includes information about source locations
+ * and original source text.
+ */
+typedef struct {
+  /**
+   * The namespace for the attribute. This will usually be
+   * `GUMBO_ATTR_NAMESPACE_NONE`, but some XLink/XMLNS/XML attributes
+   * take special values, per:
+   * https://html.spec.whatwg.org/multipage/parsing.html#adjust-foreign-attributes
+   */
+  GumboAttributeNamespaceEnum attr_namespace;
+
+  /**
+   * The name of the attribute. This is in a freshly-allocated buffer to
+   * deal with case-normalization and is null-terminated.
+   */
+  const char* name;
+
+  /**
+   * The original text of the attribute name, as a pointer into the
+   * original source buffer.
+   */
+  GumboStringPiece original_name;
+
+  /**
+   * The value of the attribute. This is in a freshly-allocated buffer
+   * to deal with unescaping and is null-terminated. It does not include
+   * any quotes that surround the attribute. If the attribute has no
+   * value (for example, `selected` on a checkbox) this will be an empty
+   * string.
+   */
+  const char* value;
+
+  /**
+   * The original text of the value of the attribute. This points into
+   * the original source buffer. It includes any quotes that surround
+   * the attribute and you can look at `original_value.data[0]` and
+   * `original_value.data[original_value.length - 1]` to determine what
+   * the quote characters were. If the attribute has no value this will
+   * be a 0-length string.
+   */
+  GumboStringPiece original_value;
+
+  /** The starting position of the attribute name. */
+  GumboSourcePosition name_start;
+
+  /**
+   * The ending position of the attribute name. This is not always derivable
+   * from the starting position of the value because of the possibility of
+   * whitespace around the `=` sign.
+   */
+  GumboSourcePosition name_end;
+
+  /** The starting position of the attribute value. */
+  GumboSourcePosition value_start;
+
+  /** The ending position of the attribute value. */
+  GumboSourcePosition value_end;
+} GumboAttribute;
+
+/**
+ * Given a vector of `GumboAttribute`s, look up the one with the
+ * specified name and return it, or `NULL` if no such attribute exists.
+ * This uses a case-insensitive match, as HTML is case-insensitive.
+ */
+GumboAttribute* gumbo_get_attribute(const GumboVector* attrs, const char* name);
+
+/**
+ * Enum denoting the type of node. This determines the type of the
+ * `node.v` union.
+ */
+typedef enum {
+  /** Document node. `v` will be a `GumboDocument`. */
+  GUMBO_NODE_DOCUMENT,
+  /** Element node. `v` will be a `GumboElement`. */
+  GUMBO_NODE_ELEMENT,
+  /** Text node. `v` will be a `GumboText`. */
+  GUMBO_NODE_TEXT,
+  /** CDATA node. `v` will be a `GumboText`. */
+  GUMBO_NODE_CDATA,
+  /** Comment node. `v` will be a `GumboText`, excluding comment delimiters. */
+  GUMBO_NODE_COMMENT,
+  /** Text node, where all contents is whitespace. `v` will be a `GumboText`. */
+  GUMBO_NODE_WHITESPACE,
+  /**
+   * Template node. This is separate from `GUMBO_NODE_ELEMENT` because
+   * many client libraries will want to ignore the contents of template
+   * nodes, as the spec suggests. Recursing on `GUMBO_NODE_ELEMENT` will
+   * do the right thing here, while clients that want to include template
+   * contents should also check for `GUMBO_NODE_TEMPLATE`. `v` will be a
+   * `GumboElement`.
+   */
+  GUMBO_NODE_TEMPLATE
+} GumboNodeType;
+
+/**
+ * Forward declaration of GumboNode so it can be used recursively in
+ * GumboNode.parent.
+ */
+typedef struct GumboInternalNode GumboNode;
+
+/** https://dom.spec.whatwg.org/#concept-document-quirks */
+typedef enum {
+  GUMBO_DOCTYPE_NO_QUIRKS,
+  GUMBO_DOCTYPE_QUIRKS,
+  GUMBO_DOCTYPE_LIMITED_QUIRKS
+} GumboQuirksModeEnum;
+
+/**
+ * Namespaces.
+ * Unlike in X(HT)ML, namespaces in HTML5 are not denoted by a prefix.
+ * Rather, anything inside an `<svg>` tag is in the SVG namespace,
+ * anything inside the `<math>` tag is in the MathML namespace, and
+ * anything else is inside the HTML namespace. No other namespaces are
+ * supported, so this can be an `enum`.
+ */
+typedef enum {
+  GUMBO_NAMESPACE_HTML,
+  GUMBO_NAMESPACE_SVG,
+  GUMBO_NAMESPACE_MATHML
+} GumboNamespaceEnum;
+
+/**
+ * Parse flags.
+ * We track the reasons for parser insertion of nodes and store them in
+ * a bitvector in the node itself. This lets client code optimize out
+ * nodes that are implied by the HTML structure of the document, or flag
+ * constructs that may not be allowed by a style guide, or track the
+ * prevalence of incorrect or tricky HTML code.
+ */
+typedef enum {
+  /**
+   * A normal node -- both start and end tags appear in the source,
+   * nothing has been reparented.
+   */
+  GUMBO_INSERTION_NORMAL = 0,
+
+  /**
+   * A node inserted by the parser to fulfill some implicit insertion
+   * rule. This is usually set in addition to some other flag giving a
+   * more specific insertion reason; it's a generic catch-all term
+   * meaning "The start tag for this node did not appear in the document
+   * source".
+   */
+  GUMBO_INSERTION_BY_PARSER = 1 << 0,
+
+  /**
+   * A flag indicating that the end tag for this node did not appear in
+   * the document source. Note that in some cases, you can still have
+   * parser-inserted nodes with an explicit end tag. For example,
+   * `Text</html>` has `GUMBO_INSERTED_BY_PARSER` set on the `<html>`
+   * node, but `GUMBO_INSERTED_END_TAG_IMPLICITLY` is unset, as the
+   * `</html>` tag actually exists.
+   *
+   * This flag will be set only if the end tag is completely missing.
+   * In some cases, the end tag may be misplaced (e.g. a `</body>` tag
+   * with text afterwards), which will leave this flag unset and require
+   * clients to inspect the parse errors for that case.
+   */
+  GUMBO_INSERTION_IMPLICIT_END_TAG = 1 << 1,
+
+  // Value 1 << 2 was for a flag that has since been removed.
+
+  /**
+   * A flag for nodes that are inserted because their presence is
+   * implied by other tags, e.g. `<html>`, `<head>`, `<body>`,
+   * `<tbody>`, etc.
+   */
+  GUMBO_INSERTION_IMPLIED = 1 << 3,
+
+  /**
+   * A flag for nodes that are converted from their end tag equivalents.
+   * For example, `</p>` when no paragraph is open implies that the
+   * parser should create a `<p>` tag and immediately close it, while
+   * `</br>` means the same thing as `<br>`.
+   */
+  GUMBO_INSERTION_CONVERTED_FROM_END_TAG = 1 << 4,
+
+  // Value 1 << 5 was for a flag that has since been removed.
+
+  /** A flag for `<image>` tags that are rewritten as `<img>`. */
+  GUMBO_INSERTION_FROM_IMAGE = 1 << 6,
+
+  /**
+   * A flag for nodes that are cloned as a result of the reconstruction
+   * of active formatting elements. This is set only on the clone; the
+   * initial portion of the formatting run is a NORMAL node with an
+   * `IMPLICIT_END_TAG`.
+   */
+  GUMBO_INSERTION_RECONSTRUCTED_FORMATTING_ELEMENT = 1 << 7,
+
+  /** A flag for nodes that are cloned by the adoption agency algorithm. */
+  GUMBO_INSERTION_ADOPTION_AGENCY_CLONED = 1 << 8,
+
+  /** A flag for nodes that are moved by the adoption agency algorithm. */
+  GUMBO_INSERTION_ADOPTION_AGENCY_MOVED = 1 << 9,
+
+  /**
+   * A flag for nodes that have been foster-parented out of a table (or
+   * should've been foster-parented, if verbatim mode is set).
+   */
+  GUMBO_INSERTION_FOSTER_PARENTED = 1 << 10,
+} GumboParseFlags;
+
+/** Information specific to document nodes. */
+typedef struct {
+  /**
+   * An array of `GumboNode`s, containing the children of this element.
+   * This will normally consist of the `<html>` element and any comment
+   * nodes found. Pointers are owned.
+   */
+  GumboVector /* GumboNode* */ children;
+
+  /**
+   * `true` if there was an explicit doctype token, as opposed to it
+   * being omitted.
+   */
+  bool has_doctype;
+
+  // Fields from the doctype token, copied verbatim.
+  const char* name;
+  const char* public_identifier;
+  const char* system_identifier;
+
+  /**
+   * Whether or not the document is in QuirksMode, as determined by the
+   * values in the GumboTokenDocType template.
+   */
+  GumboQuirksModeEnum doc_type_quirks_mode;
+} GumboDocument;
+
+/**
+ * The struct used to represent TEXT, CDATA, COMMENT, and WHITESPACE
+ * elements. This contains just a block of text and its position.
+ */
+typedef struct {
+  /**
+   * The text of this node, after entities have been parsed and decoded.
+   * For comment and cdata nodes, this does not include the comment
+   * delimiters.
+   */
+  const char* text;
+
+  /**
+   * The original text of this node, as a pointer into the original
+   * buffer. For comment/cdata nodes, this includes the comment
+   * delimiters.
+   */
+  GumboStringPiece original_text;
+
+  /**
+   * The starting position of this node. This corresponds to the
+   * position of `original_text`, before entities are decoded.
+   * */
+  GumboSourcePosition start_pos;
+} GumboText;
+
+/**
+ * The struct used to represent all HTML elements. This contains
+ * information about the tag, attributes, and child nodes.
+ */
+typedef struct {
+  /**
+   * An array of `GumboNode`s, containing the children of this element.
+   * Pointers are owned.
+   */
+  GumboVector /* GumboNode* */ children;
+
+  /** The GumboTag enum for this element. */
+  GumboTag tag;
+
+  /** The name for this element. */
+  const char* name;
+
+  /** The GumboNamespaceEnum for this element. */
+  GumboNamespaceEnum tag_namespace;
+
+  /**
+   * A `GumboStringPiece` pointing to the original tag text for this
+   * element, pointing directly into the source buffer. If the tag was
+   * inserted algorithmically (for example, `<head>` or `<tbody>`
+   * insertion), this will be a zero-length string.
+   */
+  GumboStringPiece original_tag;
+
+  /**
+   * A `GumboStringPiece` pointing to the original end tag text for this
+   * element. If the end tag was inserted algorithmically, (for example,
+   * closing a self-closing tag), this will be a zero-length string.
+   */
+  GumboStringPiece original_end_tag;
+
+  /** The source position for the start of the start tag. */
+  GumboSourcePosition start_pos;
+
+  /** The source position for the start of the end tag. */
+  GumboSourcePosition end_pos;
+
+  /**
+   * An array of `GumboAttribute`s, containing the attributes for this
+   * tag in the order that they were parsed. Pointers are owned.
+   */
+  GumboVector /* GumboAttribute* */ attributes;
+} GumboElement;
+
+/**
+ * A supertype for `GumboElement` and `GumboText`, so that we can
+ * include one generic type in lists of children and cast as necessary
+ * to subtypes.
+ */
+struct GumboInternalNode {
+  /** The type of node that this is. */
+  GumboNodeType type;
+
+  /** Pointer back to parent node. Not owned. */
+  GumboNode* parent;
+
+  /** The index within the parent's children vector of this node. */
+  unsigned int index_within_parent;
+
+  /**
+   * A bitvector of flags containing information about why this element
+   * was inserted into the parse tree, including a variety of special
+   * parse situations.
+   */
+  GumboParseFlags parse_flags;
+
+  /** The actual node data. */
+  union {
+    GumboDocument document;  // For GUMBO_NODE_DOCUMENT.
+    GumboElement element;    // For GUMBO_NODE_ELEMENT.
+    GumboText text;          // For everything else.
+  } v;
+};
+
+/**
+ * Input struct containing configuration options for the parser.
+ * These let you specify alternate memory managers, provide different
+ * error handling, etc. Use `kGumboDefaultOptions` for sensible
+ * defaults and only set what you need.
+ */
+typedef struct GumboInternalOptions {
+  /**
+   * The tab-stop size, for computing positions in HTML files that
+   * use tabs. Default: `8`.
+   */
+  int tab_stop;
+
+  /**
+   * Whether or not to stop parsing when the first error is encountered.
+   * Default: `false`.
+   */
+  bool stop_on_first_error;
+
+  /**
+   * Maximum allowed number of attributes per element. If this limit is
+   * exceeded, the parser will return early with a partial document and
+   * the returned `GumboOutput` will have its `status` field set to
+   * `GUMBO_STATUS_TOO_MANY_ATTRIBUTES`. Set to `-1` to disable the limit.
+   * Default: `400`.
+   */
+  int max_attributes;
+
+  /**
+   * Maximum allowed depth for the parse tree. If this limit is exceeded,
+   * the parser will return early with a partial document and the returned
+   * `GumboOutput` will have its `status` field set to
+   * `GUMBO_STATUS_TREE_TOO_DEEP`.
+   * Default: `400`.
+   */
+  unsigned int max_tree_depth;
+
+  /**
+   * The maximum number of errors before the parser stops recording
+   * them. This is provided so that if the page is totally borked, we
+   * don't completely fill up the errors vector and exhaust memory with
+   * useless redundant errors. Set to `-1` to disable the limit.
+   * Default: `-1`.
+   */
+  int max_errors;
+
+  /**
+   * The fragment context for parsing:
+   * https://html.spec.whatwg.org/multipage/parsing.html#parsing-html-fragments
+   *
+   * If `NULL` is passed here, it is assumed to be "no
+   * fragment", i.e. the regular parsing algorithm. Otherwise, pass the
+   * tag name for the intended parent of the parsed fragment. We use the
+   * tag name, namespace, and encoding attribute which are sufficient to
+   * set all of the parsing context needed for fragment parsing.
+   *
+   * Default: `NULL`.
+   */
+  const char* 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;
+
+  /**
+   * The value of the fragment context's `encoding` attribute, if any.
+   * Set to `NULL` for no `encoding` attribute.
+   *
+   * Default: `NULL`.
+   */
+  const char* fragment_encoding;
+
+  /**
+   * Quirks mode for fragment parsing. The quirks mode for a given DOCTYPE can
+   * be looked up using `gumbo_compute_quirks_mode()`.
+   *
+   * Default: `GUMBO_DOCTYPE_NO_QUIRKS`.
+   */
+  GumboQuirksModeEnum quirks_mode;
+
+  /**
+   * For fragment parsing. Set this to true if the context node has a form
+   * element as an ancestor.
+   *
+   * Default: `false`.
+   */
+  bool fragment_context_has_form_ancestor;
+} GumboOptions;
+
+/** Default options struct; use this with gumbo_parse_with_options. */
+extern const GumboOptions kGumboDefaultOptions;
+
+/**
+ * Status code indicating whether parsing finished successfully or
+ * was stopped mid-document due to exceptional circumstances.
+ */
+typedef enum {
+  /**
+   * Indicates that parsing completed successfuly. The resulting tree
+   * will be a complete document.
+   */
+  GUMBO_STATUS_OK,
+
+  /**
+   * Indicates that the maximum element nesting limit
+   * (`GumboOptions::max_tree_depth`) was reached during parsing. The
+   * resulting tree will be a partial document, with no further nodes
+   * created after the point where the limit was reached. The partial
+   * document may be useful for constructing an error message but
+   * typically shouldn't be used for other purposes.
+   */
+  GUMBO_STATUS_TREE_TOO_DEEP,
+
+  /**
+   * Indicates that the maximum number of attributes per element
+   * (`GumboOptions::max_attributes`) was reached during parsing. The
+   * resulting tree will be a partial document, with no further nodes
+   * created after the point where the limit was reached. The partial
+   * document may be useful for constructing an error message but
+   * typically shouldn't be used for other purposes.
+   */
+  GUMBO_STATUS_TOO_MANY_ATTRIBUTES,
+
+  // Currently unused
+  GUMBO_STATUS_OUT_OF_MEMORY,
+} GumboOutputStatus;
+
+
+/** The output struct containing the results of the parse. */
+typedef struct GumboInternalOutput {
+  /**
+   * Pointer to the document node. This is a `GumboNode` of type
+   * `NODE_DOCUMENT` that contains the entire document as its child.
+   */
+  GumboNode* document;
+
+  /**
+   * Pointer to the root node. This is the `<html>` tag that forms the
+   * root of the document.
+   */
+  GumboNode* root;
+
+  /**
+   * A list of errors that occurred during the parse.
+   */
+  GumboVector /* GumboError */ errors;
+
+  /**
+   * True if the parser encounted an error.
+   *
+   * This can be true and `errors` an empty `GumboVector` if the `max_errors`
+   * option was set to 0.
+   */
+  bool document_error;
+
+  /**
+   * A status code indicating whether parsing finished successfully or was
+   * stopped mid-document due to exceptional circumstances.
+   */
+  GumboOutputStatus status;
+} GumboOutput;
+
+/**
+ * Parses a buffer of UTF-8 text into an `GumboNode` parse tree. The
+ * buffer must live at least as long as the parse tree, as some fields
+ * (eg. `original_text`) point directly into the original buffer.
+ *
+ * This doesn't support buffers longer than 4 gigabytes.
+ */
+GumboOutput* gumbo_parse(const char* buffer);
+
+/**
+ * Extended version of `gumbo_parse` that takes an explicit options
+ * structure, buffer, and length.
+ */
+GumboOutput* gumbo_parse_with_options (
+  const GumboOptions* options,
+  const char* buffer,
+  size_t buffer_length
+);
+
+/**
+ * Compute the quirks mode based on the name, public identifier, and system
+ * identifier. Any of these may be `NULL` to indicate a missing value.
+ */
+GumboQuirksModeEnum gumbo_compute_quirks_mode (
+  const char *name,
+  const char *pubid,
+  const char *sysid
+);
+
+/** Convert a `GumboOutputStatus` code into a readable description. */
+const char* gumbo_status_to_string(GumboOutputStatus status);
+
+/** Release the memory used for the parse tree and parse errors. */
+void gumbo_destroy_output(GumboOutput* output);
+
+/** Opaque GumboError type */
+typedef struct GumboInternalError GumboError;
+
+/**
+ * Returns the position of the error.
+ */
+GumboSourcePosition gumbo_error_position(const GumboError* error);
+
+/**
+ * Returns a constant string representation of the error's code. This is owned
+ * by the library and should not be freed by the caller.
+ */
+const char* gumbo_error_code(const GumboError* error);
+
+/**
+ * Prints an error to a string. This stores a freshly-allocated buffer
+ * containing the error message text in output. The caller is responsible for
+ * freeing the buffer. The size of the error message is returned. The error
+ * message itself may not be NULL-terminated and may contain NULL bytes so the
+ * returned size must be used.
+ */
+size_t gumbo_error_to_string(const GumboError* error, char **output);
+
+/**
+ * Prints a caret diagnostic to a string. This stores a freshly-allocated
+ * buffer containing the error message text in output. The caller is responsible for
+ * freeing the buffer. The size of the error message is returned. The error
+ * message itself may not be NULL-terminated and may contain NULL bytes so the
+ * returned size must be used.
+ */
+size_t gumbo_caret_diagnostic_to_string (
+  const GumboError* error,
+  const char* source_text,
+  size_t source_length,
+  char** output
+);
+
+/**
+ * Like gumbo_caret_diagnostic_to_string, but prints the text to stdout
+ * instead of writing to a string.
+ */
+void gumbo_print_caret_diagnostic (
+  const GumboError* error,
+  const char* source_text,
+  size_t source_length
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GUMBO_H