nokogiri 1.10.7 → 1.16.0

data/gumbo-parser/src/parser.h

@@ -0,0 +1,41 @@
+#ifndef GUMBO_PARSER_H_
+#define GUMBO_PARSER_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Contains the definition of the top-level GumboParser structure that's
+// threaded through basically every internal function in the library.
+
+struct GumboInternalParserState;
+struct GumboInternalOutput;
+struct GumboInternalOptions;
+struct GumboInternalTokenizerState;
+
+// An overarching struct that's threaded through (nearly) all functions in the
+// library, OOP-style. This gives each function access to the options and
+// output, along with any internal state needed for the parse.
+typedef struct GumboInternalParser {
+  // Settings for this parse run.
+  const struct GumboInternalOptions* _options;
+
+  // Output for the parse.
+  struct GumboInternalOutput* _output;
+
+  // The internal tokenizer state, defined as a pointer to avoid a cyclic
+  // dependency on html5tokenizer.h. The main parse routine is responsible for
+  // initializing this on parse start, and destroying it on parse end.
+  // End-users will never see a non-garbage value in this pointer.
+  struct GumboInternalTokenizerState* _tokenizer_state;
+
+  // The internal parser state. Initialized on parse start and destroyed on
+  // parse end; end-users will never see a non-garbage value in this pointer.
+  struct GumboInternalParserState* _parser_state;
+} GumboParser;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // GUMBO_PARSER_H_

data/gumbo-parser/src/replacement.h

@@ -0,0 +1,33 @@
+#ifndef GUMBO_REPLACEMENT_H_
+#define GUMBO_REPLACEMENT_H_
+
+#include <stddef.h>
+#include "nokogiri_gumbo.h"
+
+typedef struct {
+  const char *const from;
+  const char *const to;
+} StringReplacement;
+
+const StringReplacement *gumbo_get_svg_tag_replacement (
+  const char* str,
+  size_t len
+);
+
+const StringReplacement *gumbo_get_svg_attr_replacement (
+  const char* str,
+  size_t len
+);
+
+typedef struct {
+  const char *const from;
+  const char *const local_name;
+  const GumboAttributeNamespaceEnum attr_namespace;
+} ForeignAttrReplacement;
+
+const ForeignAttrReplacement *gumbo_get_foreign_attr_replacement (
+  const char* str,
+  size_t len
+);
+
+#endif // GUMBO_REPLACEMENT_H_

data/gumbo-parser/src/string_buffer.c

@@ -0,0 +1,103 @@
+/*
+ Copyright 2010 Google Inc.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+#include <string.h>
+#include "string_buffer.h"
+#include "util.h"
+
+// Size chosen via statistical analysis of ~60K websites.
+// 99% of text nodes and 98% of attribute names/values fit in this initial size.
+static const size_t kDefaultStringBufferSize = 5;
+
+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) {
+    buffer->data = gumbo_realloc(buffer->data, new_capacity);
+    buffer->capacity = new_capacity;
+  }
+}
+
+void gumbo_string_buffer_init(GumboStringBuffer* output) {
+  output->data = gumbo_alloc(kDefaultStringBufferSize);
+  output->length = 0;
+  output->capacity = kDefaultStringBufferSize;
+}
+
+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 (
+  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.
+  int num_bytes, prefix;
+  if (c <= 0x7f) {
+    num_bytes = 0;
+    prefix = 0;
+  } else if (c <= 0x7ff) {
+    num_bytes = 1;
+    prefix = 0xc0;
+  } else if (c <= 0xffff) {
+    num_bytes = 2;
+    prefix = 0xe0;
+  } else {
+    num_bytes = 3;
+    prefix = 0xf0;
+  }
+  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 (
+  const GumboStringPiece* str,
+  GumboStringBuffer* output
+) {
+  maybe_resize_string_buffer(str->length, output);
+  memcpy(output->data + output->length, str->data, str->length);
+  output->length += str->length;
+}
+
+char* gumbo_string_buffer_to_string(const GumboStringBuffer* input) {
+  char* buffer = gumbo_alloc(input->length + 1);
+  memcpy(buffer, input->data, input->length);
+  buffer[input->length] = '\0';
+  return buffer;
+}
+
+void gumbo_string_buffer_clear(GumboStringBuffer* input) {
+  input->length = 0;
+}
+
+void gumbo_string_buffer_destroy(GumboStringBuffer* buffer) {
+  gumbo_free(buffer->data);
+}

data/gumbo-parser/src/string_buffer.h

@@ -0,0 +1,68 @@
+#ifndef GUMBO_STRING_BUFFER_H_
+#define GUMBO_STRING_BUFFER_H_
+
+#include <stdbool.h>
+#include <stddef.h>
+
+#include "nokogiri_gumbo.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// 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
+// it needs to be. Note that the internal buffer here is *not* nul-terminated,
+// so be sure not to use ordinary string manipulation functions on it.
+typedef struct {
+  // A pointer to the beginning of the string. NULL if length == 0.
+  char* data;
+
+  // The length of the string fragment, in bytes. May be zero.
+  size_t length;
+
+  // The capacity of the buffer, in bytes.
+  size_t capacity;
+} GumboStringBuffer;
+
+// Initializes a new GumboStringBuffer.
+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 (
+  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 (
+  int c,
+  GumboStringBuffer* output
+);
+
+// Appends a string onto the end of the GumboStringBuffer.
+void gumbo_string_buffer_append_string (
+  const GumboStringPiece* str,
+  GumboStringBuffer* output
+);
+
+// Converts this string buffer to const char*, alloctaing a new buffer for it.
+char* gumbo_string_buffer_to_string(const GumboStringBuffer* input);
+
+// Reinitialize this string buffer. This clears it by setting length=0. It
+// does not zero out the buffer itself.
+void gumbo_string_buffer_clear(GumboStringBuffer* input);
+
+// Deallocates this GumboStringBuffer.
+void gumbo_string_buffer_destroy(GumboStringBuffer* buffer);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GUMBO_STRING_BUFFER_H_

data/gumbo-parser/src/string_piece.c

@@ -0,0 +1,48 @@
+/*
+ Copyright 2018 Craig Barnes.
+ Copyright 2010 Google Inc.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+#include <stddef.h>
+#include <string.h>
+#include "nokogiri_gumbo.h"
+#include "ascii.h"
+
+bool gumbo_string_equals (
+  const GumboStringPiece* str1,
+  const GumboStringPiece* str2
+) {
+  return
+    str1->length == str2->length
+    && !memcmp(str1->data, str2->data, str1->length);
+}
+
+bool gumbo_string_equals_ignore_case (
+  const GumboStringPiece* str1,
+  const GumboStringPiece* str2
+) {
+  return
+    str1->length == str2->length
+    && !gumbo_ascii_strncasecmp(str1->data, str2->data, str1->length);
+}
+
+bool gumbo_string_prefix_ignore_case (
+  const GumboStringPiece* prefix,
+  const GumboStringPiece* str
+) {
+  return
+    prefix->length <= str->length
+    && !gumbo_ascii_strncasecmp(prefix->data, str->data, prefix->length);
+}

data/gumbo-parser/src/svg_attrs.c

@@ -0,0 +1,174 @@
+/* ANSI-C code produced by gperf version 3.1 */
+/* Command-line: gperf -m100 src/svg_attrs.gperf  */
+/* Computed positions: -k'1,10,$' */
+/* Filtered by: gperf-filter.sed */
+
+#include "replacement.h"
+#include "macros.h"
+#include "ascii.h"
+#include <string.h>
+
+#define TOTAL_KEYWORDS 58
+#define MIN_WORD_LENGTH 4
+#define MAX_WORD_LENGTH 19
+#define MIN_HASH_VALUE 5
+#define MAX_HASH_VALUE 77
+/* maximum key range = 73, duplicates = 0 */
+
+
+
+static inline unsigned int
+hash (register const char *str, register size_t len)
+{
+  static const unsigned char asso_values[] =
+    {
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78,  5, 78, 39, 14,  1,
+      31, 31, 13, 13, 78, 78, 22, 25, 10,  2,
+       7, 78, 22,  0,  1,  3,  1, 78,  0, 36,
+      14, 17, 20, 78, 78, 78, 78,  5, 78, 39,
+      14,  1, 31, 31, 13, 13, 78, 78, 22, 25,
+      10,  2,  7, 78, 22,  0,  1,  3,  1, 78,
+       0, 36, 14, 17, 20, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78
+    };
+  register unsigned int hval = len;
+
+  switch (hval)
+    {
+      default:
+        hval += asso_values[(unsigned char)str[9]];
+      /*FALLTHROUGH*/
+      case 9:
+      case 8:
+      case 7:
+      case 6:
+      case 5:
+      case 4:
+      case 3:
+      case 2:
+      case 1:
+        hval += asso_values[(unsigned char)str[0]+2];
+        break;
+    }
+  return hval + asso_values[(unsigned char)str[len - 1]];
+}
+
+const StringReplacement *
+gumbo_get_svg_attr_replacement (register const char *str, register size_t len)
+{
+  static const unsigned char lengthtable[] =
+    {
+       0,  0,  0,  0,  0,  4,  0,  7,  7,  0,  8,  9, 10, 11,
+      11, 11, 11, 10, 16, 18, 16, 12, 16, 11, 13, 11, 12, 11,
+      16,  0, 17,  9,  9,  8,  9, 10, 13, 10, 12, 14,  8,  4,
+      12, 19,  7,  9, 12, 12, 11, 14, 10, 19,  8, 16, 13, 16,
+      16, 15, 10, 12,  0,  0, 13, 13, 13,  0,  0,  9, 16,  0,
+       0,  0,  0,  0,  0,  0,  0, 17
+    };
+  static const StringReplacement wordlist[] =
+    {
+      {(char*)0,(char*)0}, {(char*)0,(char*)0},
+      {(char*)0,(char*)0}, {(char*)0,(char*)0},
+      {(char*)0,(char*)0},
+      {"refx", "refX"},
+      {(char*)0,(char*)0},
+      {"viewbox", "viewBox"},
+      {"targetx", "targetX"},
+      {(char*)0,(char*)0},
+      {"calcmode", "calcMode"},
+      {"maskunits", "maskUnits"},
+      {"viewtarget", "viewTarget"},
+      {"tablevalues", "tableValues"},
+      {"markerunits", "markerUnits"},
+      {"stitchtiles", "stitchTiles"},
+      {"startoffset", "startOffset"},
+      {"numoctaves", "numOctaves"},
+      {"requiredfeatures", "requiredFeatures"},
+      {"requiredextensions", "requiredExtensions"},
+      {"specularexponent", "specularExponent"},
+      {"surfacescale", "surfaceScale"},
+      {"specularconstant", "specularConstant"},
+      {"repeatcount", "repeatCount"},
+      {"clippathunits", "clipPathUnits"},
+      {"filterunits", "filterUnits"},
+      {"lengthadjust", "lengthAdjust"},
+      {"markerwidth", "markerWidth"},
+      {"maskcontentunits", "maskContentUnits"},
+      {(char*)0,(char*)0},
+      {"limitingconeangle", "limitingConeAngle"},
+      {"pointsatx", "pointsAtX"},
+      {"repeatdur", "repeatDur"},
+      {"keytimes", "keyTimes"},
+      {"keypoints", "keyPoints"},
+      {"keysplines", "keySplines"},
+      {"gradientunits", "gradientUnits"},
+      {"textlength", "textLength"},
+      {"stddeviation", "stdDeviation"},
+      {"primitiveunits", "primitiveUnits"},
+      {"edgemode", "edgeMode"},
+      {"refy", "refY"},
+      {"spreadmethod", "spreadMethod"},
+      {"preserveaspectratio", "preserveAspectRatio"},
+      {"targety", "targetY"},
+      {"pointsatz", "pointsAtZ"},
+      {"markerheight", "markerHeight"},
+      {"patternunits", "patternUnits"},
+      {"baseprofile", "baseProfile"},
+      {"systemlanguage", "systemLanguage"},
+      {"zoomandpan", "zoomAndPan"},
+      {"patterncontentunits", "patternContentUnits"},
+      {"glyphref", "glyphRef"},
+      {"xchannelselector", "xChannelSelector"},
+      {"attributetype", "attributeType"},
+      {"kernelunitlength", "kernelUnitLength"},
+      {"ychannelselector", "yChannelSelector"},
+      {"diffuseconstant", "diffuseConstant"},
+      {"pathlength", "pathLength"},
+      {"kernelmatrix", "kernelMatrix"},
+      {(char*)0,(char*)0}, {(char*)0,(char*)0},
+      {"preservealpha", "preserveAlpha"},
+      {"attributename", "attributeName"},
+      {"basefrequency", "baseFrequency"},
+      {(char*)0,(char*)0}, {(char*)0,(char*)0},
+      {"pointsaty", "pointsAtY"},
+      {"patterntransform", "patternTransform"},
+      {(char*)0,(char*)0}, {(char*)0,(char*)0},
+      {(char*)0,(char*)0}, {(char*)0,(char*)0},
+      {(char*)0,(char*)0}, {(char*)0,(char*)0},
+      {(char*)0,(char*)0}, {(char*)0,(char*)0},
+      {"gradienttransform", "gradientTransform"}
+    };
+
+  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 && (((unsigned char)*str ^ (unsigned char)*s) & ~32) == 0 && !gumbo_ascii_strncasecmp(str, s, len))
+              return &wordlist[key];
+          }
+    }
+  return 0;
+}

data/gumbo-parser/src/svg_attrs.gperf

@@ -0,0 +1,77 @@
+%{
+#include "replacement.h"
+#include "macros.h"
+#include "ascii.h"
+%}
+
+%ignore-case
+%struct-type
+%omit-struct-type
+%compare-lengths
+%readonly-tables
+%null-strings
+%includes
+%define lookup-function-name gumbo_get_svg_attr_replacement
+%define slot-name from
+%define initializer-suffix ,(char*)0
+StringReplacement;
+
+%%
+"attributename", "attributeName"
+"attributetype", "attributeType"
+"basefrequency", "baseFrequency"
+"baseprofile", "baseProfile"
+"calcmode", "calcMode"
+"clippathunits", "clipPathUnits"
+"diffuseconstant", "diffuseConstant"
+"edgemode", "edgeMode"
+"filterunits", "filterUnits"
+"glyphref", "glyphRef"
+"gradienttransform", "gradientTransform"
+"gradientunits", "gradientUnits"
+"kernelmatrix", "kernelMatrix"
+"kernelunitlength", "kernelUnitLength"
+"keypoints", "keyPoints"
+"keysplines", "keySplines"
+"keytimes", "keyTimes"
+"lengthadjust", "lengthAdjust"
+"limitingconeangle", "limitingConeAngle"
+"markerheight", "markerHeight"
+"markerunits", "markerUnits"
+"markerwidth", "markerWidth"
+"maskcontentunits", "maskContentUnits"
+"maskunits", "maskUnits"
+"numoctaves", "numOctaves"
+"pathlength", "pathLength"
+"patterncontentunits", "patternContentUnits"
+"patterntransform", "patternTransform"
+"patternunits", "patternUnits"
+"pointsatx", "pointsAtX"
+"pointsaty", "pointsAtY"
+"pointsatz", "pointsAtZ"
+"preservealpha", "preserveAlpha"
+"preserveaspectratio", "preserveAspectRatio"
+"primitiveunits", "primitiveUnits"
+"refx", "refX"
+"refy", "refY"
+"repeatcount", "repeatCount"
+"repeatdur", "repeatDur"
+"requiredextensions", "requiredExtensions"
+"requiredfeatures", "requiredFeatures"
+"specularconstant", "specularConstant"
+"specularexponent", "specularExponent"
+"spreadmethod", "spreadMethod"
+"startoffset", "startOffset"
+"stddeviation", "stdDeviation"
+"stitchtiles", "stitchTiles"
+"surfacescale", "surfaceScale"
+"systemlanguage", "systemLanguage"
+"tablevalues", "tableValues"
+"targetx", "targetX"
+"targety", "targetY"
+"textlength", "textLength"
+"viewbox", "viewBox"
+"viewtarget", "viewTarget"
+"xchannelselector", "xChannelSelector"
+"ychannelselector", "yChannelSelector"
+"zoomandpan", "zoomAndPan"

data/gumbo-parser/src/svg_tags.c

@@ -0,0 +1,137 @@
+/* ANSI-C code produced by gperf version 3.1 */
+/* Command-line: gperf -m100 src/svg_tags.gperf  */
+/* Computed positions: -k'3,7' */
+/* Filtered by: gperf-filter.sed */
+
+#include "replacement.h"
+#include "macros.h"
+#include "ascii.h"
+#include <string.h>
+
+#define TOTAL_KEYWORDS 36
+#define MIN_WORD_LENGTH 6
+#define MAX_WORD_LENGTH 19
+#define MIN_HASH_VALUE 6
+#define MAX_HASH_VALUE 42
+/* maximum key range = 37, duplicates = 0 */
+
+
+
+static inline unsigned int
+hash (register const char *str, register size_t len)
+{
+  static const unsigned char asso_values[] =
+    {
+      43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+      43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+      43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+      43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+      43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+      43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+      43, 43, 43, 43, 43, 43, 12,  2, 10, 22,
+       1, 28, 15,  1, 43, 43, 43,  0,  9, 26,
+       3, 17,  1, 11,  0, 22,  5, 43,  3,  2,
+      43, 43, 43, 43, 43, 43, 43, 43, 12,  2,
+      10, 22,  1, 28, 15,  1, 43, 43, 43,  0,
+       9, 26,  3, 17,  1, 11,  0, 22,  5, 43,
+       3,  2, 43, 43, 43, 43, 43, 43, 43, 43,
+      43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+      43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+      43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+      43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+      43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+      43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+      43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+      43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+      43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+      43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+      43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+      43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+      43, 43, 43, 43, 43, 43, 43
+    };
+  register unsigned int hval = len;
+
+  switch (hval)
+    {
+      default:
+        hval += asso_values[(unsigned char)str[6]+1];
+      /*FALLTHROUGH*/
+      case 6:
+      case 5:
+      case 4:
+      case 3:
+        hval += asso_values[(unsigned char)str[2]];
+        break;
+    }
+  return hval;
+}
+
+const StringReplacement *
+gumbo_get_svg_tag_replacement (register const char *str, register size_t len)
+{
+  static const unsigned char lengthtable[] =
+    {
+       0,  0,  0,  0,  0,  0,  6,  0,  7,  7,  7,  8, 11, 12,
+      12, 13, 11, 12, 16,  7,  7, 16, 11,  7, 19,  8, 13, 17,
+      11, 12,  7,  8, 17,  8, 18,  8, 14, 12, 14, 14, 13,  7,
+      14
+    };
+  static const StringReplacement wordlist[] =
+    {
+      {(char*)0,(char*)0}, {(char*)0,(char*)0},
+      {(char*)0,(char*)0}, {(char*)0,(char*)0},
+      {(char*)0,(char*)0}, {(char*)0,(char*)0},
+      {"fetile", "feTile"},
+      {(char*)0,(char*)0},
+      {"femerge", "feMerge"},
+      {"feimage", "feImage"},
+      {"fefuncb", "feFuncB"},
+      {"glyphref", "glyphRef"},
+      {"femergenode", "feMergeNode"},
+      {"femorphology", "feMorphology"},
+      {"animatecolor", "animateColor"},
+      {"animatemotion", "animateMotion"},
+      {"fecomposite", "feComposite"},
+      {"feturbulence", "feTurbulence"},
+      {"animatetransform", "animateTransform"},
+      {"fefuncr", "feFuncR"},
+      {"fefunca", "feFuncA"},
+      {"feconvolvematrix", "feConvolveMatrix"},
+      {"fespotlight", "feSpotLight"},
+      {"fefuncg", "feFuncG"},
+      {"fecomponenttransfer", "feComponentTransfer"},
+      {"altglyph", "altGlyph"},
+      {"fecolormatrix", "feColorMatrix"},
+      {"fedisplacementmap", "feDisplacementMap"},
+      {"altglyphdef", "altGlyphDef"},
+      {"altglyphitem", "altGlyphItem"},
+      {"feflood", "feFlood"},
+      {"clippath", "clipPath"},
+      {"fediffuselighting", "feDiffuseLighting"},
+      {"textpath", "textPath"},
+      {"fespecularlighting", "feSpecularLighting"},
+      {"feoffset", "feOffset"},
+      {"fedistantlight", "feDistantLight"},
+      {"fepointlight", "fePointLight"},
+      {"lineargradient", "linearGradient"},
+      {"radialgradient", "radialGradient"},
+      {"foreignobject", "foreignObject"},
+      {"feblend", "feBlend"},
+      {"fegaussianblur", "feGaussianBlur"}
+    };
+
+  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 && (((unsigned char)*str ^ (unsigned char)*s) & ~32) == 0 && !gumbo_ascii_strncasecmp(str, s, len))
+              return &wordlist[key];
+          }
+    }
+  return 0;
+}