From 5a8dbc6347b3541e84fe669b22c17ad3b715e258 Mon Sep 17 00:00:00 2001 From: Mitja Felicijan Date: Wed, 21 Jan 2026 20:22:09 +0100 Subject: Engage! --- .../mitjafelicijan/go-tree-sitter/html/binding.go | 15 + .../mitjafelicijan/go-tree-sitter/html/parser.c | 2300 ++++++++++++++++++++ .../mitjafelicijan/go-tree-sitter/html/parser.h | 265 +++ .../mitjafelicijan/go-tree-sitter/html/scanner.c | 362 +++ .../mitjafelicijan/go-tree-sitter/html/tag.h | 385 ++++ 5 files changed, 3327 insertions(+) create mode 100644 vendor/github.com/mitjafelicijan/go-tree-sitter/html/binding.go create mode 100644 vendor/github.com/mitjafelicijan/go-tree-sitter/html/parser.c create mode 100644 vendor/github.com/mitjafelicijan/go-tree-sitter/html/parser.h create mode 100644 vendor/github.com/mitjafelicijan/go-tree-sitter/html/scanner.c create mode 100644 vendor/github.com/mitjafelicijan/go-tree-sitter/html/tag.h (limited to 'vendor/github.com/mitjafelicijan/go-tree-sitter/html') diff --git a/vendor/github.com/mitjafelicijan/go-tree-sitter/html/binding.go b/vendor/github.com/mitjafelicijan/go-tree-sitter/html/binding.go new file mode 100644 index 0000000..6d5dd0a --- /dev/null +++ b/vendor/github.com/mitjafelicijan/go-tree-sitter/html/binding.go @@ -0,0 +1,15 @@ +package html + +//#include "parser.h" +//TSLanguage *tree_sitter_html(); +import "C" +import ( + "unsafe" + + sitter "github.com/mitjafelicijan/go-tree-sitter" +) + +func GetLanguage() *sitter.Language { + ptr := unsafe.Pointer(C.tree_sitter_html()) + return sitter.NewLanguage(ptr) +} diff --git a/vendor/github.com/mitjafelicijan/go-tree-sitter/html/parser.c b/vendor/github.com/mitjafelicijan/go-tree-sitter/html/parser.c new file mode 100644 index 0000000..5e899a6 --- /dev/null +++ b/vendor/github.com/mitjafelicijan/go-tree-sitter/html/parser.c @@ -0,0 +1,2300 @@ +#include "parser.h" + +#if defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic ignored "-Wmissing-field-initializers" +#endif + +#define LANGUAGE_VERSION 14 +#define STATE_COUNT 94 +#define LARGE_STATE_COUNT 2 +#define SYMBOL_COUNT 41 +#define ALIAS_COUNT 0 +#define TOKEN_COUNT 25 +#define EXTERNAL_TOKEN_COUNT 9 +#define FIELD_COUNT 0 +#define MAX_ALIAS_SEQUENCE_LENGTH 4 +#define PRODUCTION_ID_COUNT 1 + +enum ts_symbol_identifiers { + anon_sym_LT_BANG = 1, + aux_sym_doctype_token1 = 2, + anon_sym_GT = 3, + sym__doctype = 4, + anon_sym_LT = 5, + anon_sym_SLASH_GT = 6, + anon_sym_LT_SLASH = 7, + anon_sym_EQ = 8, + sym_attribute_name = 9, + sym_attribute_value = 10, + sym_entity = 11, + anon_sym_SQUOTE = 12, + aux_sym_quoted_attribute_value_token1 = 13, + anon_sym_DQUOTE = 14, + aux_sym_quoted_attribute_value_token2 = 15, + sym_text = 16, + sym__start_tag_name = 17, + sym__script_start_tag_name = 18, + sym__style_start_tag_name = 19, + sym__end_tag_name = 20, + sym_erroneous_end_tag_name = 21, + sym__implicit_end_tag = 22, + sym_raw_text = 23, + sym_comment = 24, + sym_document = 25, + sym_doctype = 26, + sym__node = 27, + sym_element = 28, + sym_script_element = 29, + sym_style_element = 30, + sym_start_tag = 31, + sym_script_start_tag = 32, + sym_style_start_tag = 33, + sym_self_closing_tag = 34, + sym_end_tag = 35, + sym_erroneous_end_tag = 36, + sym_attribute = 37, + sym_quoted_attribute_value = 38, + aux_sym_document_repeat1 = 39, + aux_sym_start_tag_repeat1 = 40, +}; + +static const char * const ts_symbol_names[] = { + [ts_builtin_sym_end] = "end", + [anon_sym_LT_BANG] = "", + [sym__doctype] = "doctype", + [anon_sym_LT] = "<", + [anon_sym_SLASH_GT] = "/>", + [anon_sym_LT_SLASH] = "eof(lexer); + switch (state) { + case 0: + if (eof) ADVANCE(18); + ADVANCE_MAP( + '"', 73, + '&', 3, + '\'', 70, + '/', 6, + '<', 24, + '=', 27, + '>', 22, + 'D', 9, + 'd', 9, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(0); + END_STATE(); + case 1: + if (lookahead == '"') ADVANCE(73); + if (lookahead == '\'') ADVANCE(70); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(1); + if (lookahead != 0 && + (lookahead < '<' || '>' < lookahead)) ADVANCE(29); + END_STATE(); + case 2: + if (lookahead == '"') ADVANCE(73); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(74); + if (lookahead != 0) ADVANCE(75); + END_STATE(); + case 3: + if (lookahead == '#') ADVANCE(12); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(69); + END_STATE(); + case 4: + if (lookahead == '\'') ADVANCE(70); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(71); + if (lookahead != 0) ADVANCE(72); + END_STATE(); + case 5: + if (lookahead == '/') ADVANCE(6); + if (lookahead == '=') ADVANCE(27); + if (lookahead == '>') ADVANCE(22); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(5); + if (lookahead != 0 && + lookahead != '"' && + lookahead != '\'' && + (lookahead < '<' || '>' < lookahead)) ADVANCE(28); + END_STATE(); + case 6: + if (lookahead == '>') ADVANCE(25); + END_STATE(); + case 7: + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(11); + END_STATE(); + case 8: + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(23); + END_STATE(); + case 9: + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(7); + END_STATE(); + case 10: + if (lookahead == 'P' || + lookahead == 'p') ADVANCE(8); + END_STATE(); + case 11: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(13); + END_STATE(); + case 12: + if (lookahead == 'X' || + lookahead == 'x') ADVANCE(16); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(35); + END_STATE(); + case 13: + if (lookahead == 'Y' || + lookahead == 'y') ADVANCE(10); + END_STATE(); + case 14: + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(14); + if (lookahead != 0 && + lookahead != '&' && + lookahead != '<' && + lookahead != '>') ADVANCE(76); + END_STATE(); + case 15: + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(20); + if (lookahead != 0 && + lookahead != '>') ADVANCE(21); + END_STATE(); + case 16: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(40); + END_STATE(); + case 17: + if (eof) ADVANCE(18); + if (lookahead == '&') ADVANCE(3); + if (lookahead == '<') ADVANCE(24); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(17); + if (lookahead != 0 && + lookahead != '>') ADVANCE(76); + END_STATE(); + case 18: + ACCEPT_TOKEN(ts_builtin_sym_end); + END_STATE(); + case 19: + ACCEPT_TOKEN(anon_sym_LT_BANG); + END_STATE(); + case 20: + ACCEPT_TOKEN(aux_sym_doctype_token1); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(20); + if (lookahead != 0 && + lookahead != '>') ADVANCE(21); + END_STATE(); + case 21: + ACCEPT_TOKEN(aux_sym_doctype_token1); + if (lookahead != 0 && + lookahead != '>') ADVANCE(21); + END_STATE(); + case 22: + ACCEPT_TOKEN(anon_sym_GT); + END_STATE(); + case 23: + ACCEPT_TOKEN(sym__doctype); + END_STATE(); + case 24: + ACCEPT_TOKEN(anon_sym_LT); + if (lookahead == '!') ADVANCE(19); + if (lookahead == '/') ADVANCE(26); + END_STATE(); + case 25: + ACCEPT_TOKEN(anon_sym_SLASH_GT); + END_STATE(); + case 26: + ACCEPT_TOKEN(anon_sym_LT_SLASH); + END_STATE(); + case 27: + ACCEPT_TOKEN(anon_sym_EQ); + END_STATE(); + case 28: + ACCEPT_TOKEN(sym_attribute_name); + if (lookahead != 0 && + (lookahead < '\t' || '\r' < lookahead) && + lookahead != ' ' && + lookahead != '"' && + lookahead != '\'' && + lookahead != '/' && + (lookahead < '<' || '>' < lookahead)) ADVANCE(28); + END_STATE(); + case 29: + ACCEPT_TOKEN(sym_attribute_value); + if (lookahead != 0 && + (lookahead < '\t' || '\r' < lookahead) && + lookahead != ' ' && + lookahead != '"' && + lookahead != '\'' && + (lookahead < '<' || '>' < lookahead)) ADVANCE(29); + END_STATE(); + case 30: + ACCEPT_TOKEN(sym_entity); + END_STATE(); + case 31: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + END_STATE(); + case 32: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(31); + END_STATE(); + case 33: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(32); + END_STATE(); + case 34: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(33); + END_STATE(); + case 35: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(34); + END_STATE(); + case 36: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(31); + END_STATE(); + case 37: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(36); + END_STATE(); + case 38: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(37); + END_STATE(); + case 39: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(38); + END_STATE(); + case 40: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(39); + END_STATE(); + case 41: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(31); + END_STATE(); + case 42: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(41); + END_STATE(); + case 43: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(42); + END_STATE(); + case 44: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(43); + END_STATE(); + case 45: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(44); + END_STATE(); + case 46: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(45); + END_STATE(); + case 47: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(46); + END_STATE(); + case 48: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(47); + END_STATE(); + case 49: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(48); + END_STATE(); + case 50: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(49); + END_STATE(); + case 51: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(50); + END_STATE(); + case 52: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(51); + END_STATE(); + case 53: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(52); + END_STATE(); + case 54: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(53); + END_STATE(); + case 55: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(54); + END_STATE(); + case 56: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(55); + END_STATE(); + case 57: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(56); + END_STATE(); + case 58: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(57); + END_STATE(); + case 59: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(58); + END_STATE(); + case 60: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(59); + END_STATE(); + case 61: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(60); + END_STATE(); + case 62: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(61); + END_STATE(); + case 63: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(62); + END_STATE(); + case 64: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(63); + END_STATE(); + case 65: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(64); + END_STATE(); + case 66: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(65); + END_STATE(); + case 67: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(66); + END_STATE(); + case 68: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(67); + END_STATE(); + case 69: + ACCEPT_TOKEN(sym_entity); + if (lookahead == ';') ADVANCE(30); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(68); + END_STATE(); + case 70: + ACCEPT_TOKEN(anon_sym_SQUOTE); + END_STATE(); + case 71: + ACCEPT_TOKEN(aux_sym_quoted_attribute_value_token1); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(71); + if (lookahead != 0 && + lookahead != '\'') ADVANCE(72); + END_STATE(); + case 72: + ACCEPT_TOKEN(aux_sym_quoted_attribute_value_token1); + if (lookahead != 0 && + lookahead != '\'') ADVANCE(72); + END_STATE(); + case 73: + ACCEPT_TOKEN(anon_sym_DQUOTE); + END_STATE(); + case 74: + ACCEPT_TOKEN(aux_sym_quoted_attribute_value_token2); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(74); + if (lookahead != 0 && + lookahead != '"') ADVANCE(75); + END_STATE(); + case 75: + ACCEPT_TOKEN(aux_sym_quoted_attribute_value_token2); + if (lookahead != 0 && + lookahead != '"') ADVANCE(75); + END_STATE(); + case 76: + ACCEPT_TOKEN(sym_text); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(14); + if (lookahead != 0 && + lookahead != '&' && + lookahead != '<' && + lookahead != '>') ADVANCE(76); + END_STATE(); + default: + return false; + } +} + +static const TSLexMode ts_lex_modes[STATE_COUNT] = { + [0] = {.lex_state = 0, .external_lex_state = 1}, + [1] = {.lex_state = 17, .external_lex_state = 2}, + [2] = {.lex_state = 17, .external_lex_state = 3}, + [3] = {.lex_state = 17, .external_lex_state = 3}, + [4] = {.lex_state = 17, .external_lex_state = 3}, + [5] = {.lex_state = 17, .external_lex_state = 3}, + [6] = {.lex_state = 17, .external_lex_state = 3}, + [7] = {.lex_state = 17, .external_lex_state = 2}, + [8] = {.lex_state = 17, .external_lex_state = 2}, + [9] = {.lex_state = 17, .external_lex_state = 2}, + [10] = {.lex_state = 17, .external_lex_state = 2}, + [11] = {.lex_state = 17, .external_lex_state = 2}, + [12] = {.lex_state = 17, .external_lex_state = 3}, + [13] = {.lex_state = 17, .external_lex_state = 3}, + [14] = {.lex_state = 17, .external_lex_state = 2}, + [15] = {.lex_state = 17, .external_lex_state = 2}, + [16] = {.lex_state = 17, .external_lex_state = 3}, + [17] = {.lex_state = 17, .external_lex_state = 2}, + [18] = {.lex_state = 17, .external_lex_state = 3}, + [19] = {.lex_state = 17, .external_lex_state = 3}, + [20] = {.lex_state = 17, .external_lex_state = 3}, + [21] = {.lex_state = 17, .external_lex_state = 2}, + [22] = {.lex_state = 17, .external_lex_state = 3}, + [23] = {.lex_state = 17, .external_lex_state = 2}, + [24] = {.lex_state = 17, .external_lex_state = 3}, + [25] = {.lex_state = 17, .external_lex_state = 3}, + [26] = {.lex_state = 17, .external_lex_state = 3}, + [27] = {.lex_state = 17, .external_lex_state = 2}, + [28] = {.lex_state = 17, .external_lex_state = 2}, + [29] = {.lex_state = 17, .external_lex_state = 2}, + [30] = {.lex_state = 17, .external_lex_state = 3}, + [31] = {.lex_state = 17, .external_lex_state = 3}, + [32] = {.lex_state = 17, .external_lex_state = 3}, + [33] = {.lex_state = 17, .external_lex_state = 3}, + [34] = {.lex_state = 17, .external_lex_state = 2}, + [35] = {.lex_state = 5, .external_lex_state = 4}, + [36] = {.lex_state = 5, .external_lex_state = 4}, + [37] = {.lex_state = 5, .external_lex_state = 4}, + [38] = {.lex_state = 5, .external_lex_state = 4}, + [39] = {.lex_state = 5, .external_lex_state = 4}, + [40] = {.lex_state = 5, .external_lex_state = 2}, + [41] = {.lex_state = 5, .external_lex_state = 2}, + [42] = {.lex_state = 5, .external_lex_state = 4}, + [43] = {.lex_state = 1, .external_lex_state = 2}, + [44] = {.lex_state = 1, .external_lex_state = 2}, + [45] = {.lex_state = 5, .external_lex_state = 2}, + [46] = {.lex_state = 5, .external_lex_state = 2}, + [47] = {.lex_state = 5, .external_lex_state = 2}, + [48] = {.lex_state = 5, .external_lex_state = 4}, + [49] = {.lex_state = 5, .external_lex_state = 2}, + [50] = {.lex_state = 5, .external_lex_state = 4}, + [51] = {.lex_state = 0, .external_lex_state = 5}, + [52] = {.lex_state = 0, .external_lex_state = 5}, + [53] = {.lex_state = 5, .external_lex_state = 4}, + [54] = {.lex_state = 0, .external_lex_state = 6}, + [55] = {.lex_state = 0, .external_lex_state = 6}, + [56] = {.lex_state = 0, .external_lex_state = 6}, + [57] = {.lex_state = 0, .external_lex_state = 6}, + [58] = {.lex_state = 5, .external_lex_state = 2}, + [59] = {.lex_state = 0, .external_lex_state = 6}, + [60] = {.lex_state = 0, .external_lex_state = 6}, + [61] = {.lex_state = 0, .external_lex_state = 6}, + [62] = {.lex_state = 0, .external_lex_state = 7}, + [63] = {.lex_state = 0, .external_lex_state = 2}, + [64] = {.lex_state = 2, .external_lex_state = 2}, + [65] = {.lex_state = 0, .external_lex_state = 2}, + [66] = {.lex_state = 0, .external_lex_state = 7}, + [67] = {.lex_state = 4, .external_lex_state = 2}, + [68] = {.lex_state = 0, .external_lex_state = 2}, + [69] = {.lex_state = 5, .external_lex_state = 2}, + [70] = {.lex_state = 5, .external_lex_state = 2}, + [71] = {.lex_state = 2, .external_lex_state = 2}, + [72] = {.lex_state = 0, .external_lex_state = 2}, + [73] = {.lex_state = 0, .external_lex_state = 6}, + [74] = {.lex_state = 4, .external_lex_state = 2}, + [75] = {.lex_state = 0, .external_lex_state = 2}, + [76] = {.lex_state = 0, .external_lex_state = 2}, + [77] = {.lex_state = 0, .external_lex_state = 2}, + [78] = {.lex_state = 0, .external_lex_state = 2}, + [79] = {.lex_state = 15, .external_lex_state = 2}, + [80] = {.lex_state = 0, .external_lex_state = 2}, + [81] = {.lex_state = 0, .external_lex_state = 8}, + [82] = {.lex_state = 0, .external_lex_state = 2}, + [83] = {.lex_state = 0, .external_lex_state = 2}, + [84] = {.lex_state = 0, .external_lex_state = 2}, + [85] = {.lex_state = 0, .external_lex_state = 9}, + [86] = {.lex_state = 0, .external_lex_state = 2}, + [87] = {.lex_state = 0, .external_lex_state = 2}, + [88] = {.lex_state = 0, .external_lex_state = 2}, + [89] = {.lex_state = 0, .external_lex_state = 8}, + [90] = {.lex_state = 15, .external_lex_state = 2}, + [91] = {.lex_state = 0, .external_lex_state = 2}, + [92] = {.lex_state = 0, .external_lex_state = 9}, + [93] = {.lex_state = 0, .external_lex_state = 2}, +}; + +static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { + [0] = { + [ts_builtin_sym_end] = ACTIONS(1), + [anon_sym_LT_BANG] = ACTIONS(1), + [anon_sym_GT] = ACTIONS(1), + [sym__doctype] = ACTIONS(1), + [anon_sym_LT] = ACTIONS(1), + [anon_sym_SLASH_GT] = ACTIONS(1), + [anon_sym_LT_SLASH] = ACTIONS(1), + [anon_sym_EQ] = ACTIONS(1), + [sym_entity] = ACTIONS(1), + [anon_sym_SQUOTE] = ACTIONS(1), + [anon_sym_DQUOTE] = ACTIONS(1), + [sym__start_tag_name] = ACTIONS(1), + [sym__script_start_tag_name] = ACTIONS(1), + [sym__style_start_tag_name] = ACTIONS(1), + [sym__end_tag_name] = ACTIONS(1), + [sym_erroneous_end_tag_name] = ACTIONS(1), + [sym__implicit_end_tag] = ACTIONS(1), + [sym_raw_text] = ACTIONS(1), + [sym_comment] = ACTIONS(3), + }, + [1] = { + [sym_document] = STATE(77), + [sym_doctype] = STATE(8), + [sym__node] = STATE(8), + [sym_element] = STATE(8), + [sym_script_element] = STATE(8), + [sym_style_element] = STATE(8), + [sym_start_tag] = STATE(4), + [sym_script_start_tag] = STATE(54), + [sym_style_start_tag] = STATE(57), + [sym_self_closing_tag] = STATE(11), + [sym_erroneous_end_tag] = STATE(8), + [aux_sym_document_repeat1] = STATE(8), + [ts_builtin_sym_end] = ACTIONS(5), + [anon_sym_LT_BANG] = ACTIONS(7), + [anon_sym_LT] = ACTIONS(9), + [anon_sym_LT_SLASH] = ACTIONS(11), + [sym_entity] = ACTIONS(13), + [sym_text] = ACTIONS(13), + [sym_comment] = ACTIONS(3), + }, +}; + +static const uint16_t ts_small_parse_table[] = { + [0] = 12, + ACTIONS(3), 1, + sym_comment, + ACTIONS(15), 1, + anon_sym_LT_BANG, + ACTIONS(17), 1, + anon_sym_LT, + ACTIONS(19), 1, + anon_sym_LT_SLASH, + ACTIONS(23), 1, + sym__implicit_end_tag, + STATE(5), 1, + sym_start_tag, + STATE(9), 1, + sym_end_tag, + STATE(13), 1, + sym_self_closing_tag, + STATE(55), 1, + sym_style_start_tag, + STATE(56), 1, + sym_script_start_tag, + ACTIONS(21), 2, + sym_entity, + sym_text, + STATE(6), 7, + sym_doctype, + sym__node, + sym_element, + sym_script_element, + sym_style_element, + sym_erroneous_end_tag, + aux_sym_document_repeat1, + [44] = 12, + ACTIONS(3), 1, + sym_comment, + ACTIONS(15), 1, + anon_sym_LT_BANG, + ACTIONS(17), 1, + anon_sym_LT, + ACTIONS(25), 1, + anon_sym_LT_SLASH, + ACTIONS(27), 1, + sym__implicit_end_tag, + STATE(5), 1, + sym_start_tag, + STATE(13), 1, + sym_self_closing_tag, + STATE(22), 1, + sym_end_tag, + STATE(55), 1, + sym_style_start_tag, + STATE(56), 1, + sym_script_start_tag, + ACTIONS(21), 2, + sym_entity, + sym_text, + STATE(6), 7, + sym_doctype, + sym__node, + sym_element, + sym_script_element, + sym_style_element, + sym_erroneous_end_tag, + aux_sym_document_repeat1, + [88] = 12, + ACTIONS(3), 1, + sym_comment, + ACTIONS(15), 1, + anon_sym_LT_BANG, + ACTIONS(17), 1, + anon_sym_LT, + ACTIONS(19), 1, + anon_sym_LT_SLASH, + ACTIONS(31), 1, + sym__implicit_end_tag, + STATE(5), 1, + sym_start_tag, + STATE(13), 1, + sym_self_closing_tag, + STATE(17), 1, + sym_end_tag, + STATE(55), 1, + sym_style_start_tag, + STATE(56), 1, + sym_script_start_tag, + ACTIONS(29), 2, + sym_entity, + sym_text, + STATE(2), 7, + sym_doctype, + sym__node, + sym_element, + sym_script_element, + sym_style_element, + sym_erroneous_end_tag, + aux_sym_document_repeat1, + [132] = 12, + ACTIONS(3), 1, + sym_comment, + ACTIONS(15), 1, + anon_sym_LT_BANG, + ACTIONS(17), 1, + anon_sym_LT, + ACTIONS(25), 1, + anon_sym_LT_SLASH, + ACTIONS(35), 1, + sym__implicit_end_tag, + STATE(5), 1, + sym_start_tag, + STATE(12), 1, + sym_end_tag, + STATE(13), 1, + sym_self_closing_tag, + STATE(55), 1, + sym_style_start_tag, + STATE(56), 1, + sym_script_start_tag, + ACTIONS(33), 2, + sym_entity, + sym_text, + STATE(3), 7, + sym_doctype, + sym__node, + sym_element, + sym_script_element, + sym_style_element, + sym_erroneous_end_tag, + aux_sym_document_repeat1, + [176] = 11, + ACTIONS(3), 1, + sym_comment, + ACTIONS(37), 1, + anon_sym_LT_BANG, + ACTIONS(40), 1, + anon_sym_LT, + ACTIONS(43), 1, + anon_sym_LT_SLASH, + ACTIONS(49), 1, + sym__implicit_end_tag, + STATE(5), 1, + sym_start_tag, + STATE(13), 1, + sym_self_closing_tag, + STATE(55), 1, + sym_style_start_tag, + STATE(56), 1, + sym_script_start_tag, + ACTIONS(46), 2, + sym_entity, + sym_text, + STATE(6), 7, + sym_doctype, + sym__node, + sym_element, + sym_script_element, + sym_style_element, + sym_erroneous_end_tag, + aux_sym_document_repeat1, + [217] = 11, + ACTIONS(3), 1, + sym_comment, + ACTIONS(49), 1, + ts_builtin_sym_end, + ACTIONS(51), 1, + anon_sym_LT_BANG, + ACTIONS(54), 1, + anon_sym_LT, + ACTIONS(57), 1, + anon_sym_LT_SLASH, + STATE(4), 1, + sym_start_tag, + STATE(11), 1, + sym_self_closing_tag, + STATE(54), 1, + sym_script_start_tag, + STATE(57), 1, + sym_style_start_tag, + ACTIONS(60), 2, + sym_entity, + sym_text, + STATE(7), 7, + sym_doctype, + sym__node, + sym_element, + sym_script_element, + sym_style_element, + sym_erroneous_end_tag, + aux_sym_document_repeat1, + [258] = 11, + ACTIONS(3), 1, + sym_comment, + ACTIONS(7), 1, + anon_sym_LT_BANG, + ACTIONS(9), 1, + anon_sym_LT, + ACTIONS(11), 1, + anon_sym_LT_SLASH, + ACTIONS(63), 1, + ts_builtin_sym_end, + STATE(4), 1, + sym_start_tag, + STATE(11), 1, + sym_self_closing_tag, + STATE(54), 1, + sym_script_start_tag, + STATE(57), 1, + sym_style_start_tag, + ACTIONS(65), 2, + sym_entity, + sym_text, + STATE(7), 7, + sym_doctype, + sym__node, + sym_element, + sym_script_element, + sym_style_element, + sym_erroneous_end_tag, + aux_sym_document_repeat1, + [299] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(69), 1, + anon_sym_LT, + ACTIONS(67), 5, + ts_builtin_sym_end, + anon_sym_LT_BANG, + anon_sym_LT_SLASH, + sym_entity, + sym_text, + [313] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(73), 1, + anon_sym_LT, + ACTIONS(71), 5, + ts_builtin_sym_end, + anon_sym_LT_BANG, + anon_sym_LT_SLASH, + sym_entity, + sym_text, + [327] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(77), 1, + anon_sym_LT, + ACTIONS(75), 5, + ts_builtin_sym_end, + anon_sym_LT_BANG, + anon_sym_LT_SLASH, + sym_entity, + sym_text, + [341] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(81), 1, + anon_sym_LT, + ACTIONS(79), 5, + sym__implicit_end_tag, + anon_sym_LT_BANG, + anon_sym_LT_SLASH, + sym_entity, + sym_text, + [355] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(77), 1, + anon_sym_LT, + ACTIONS(75), 5, + sym__implicit_end_tag, + anon_sym_LT_BANG, + anon_sym_LT_SLASH, + sym_entity, + sym_text, + [369] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(85), 1, + anon_sym_LT, + ACTIONS(83), 5, + ts_builtin_sym_end, + anon_sym_LT_BANG, + anon_sym_LT_SLASH, + sym_entity, + sym_text, + [383] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(89), 1, + anon_sym_LT, + ACTIONS(87), 5, + ts_builtin_sym_end, + anon_sym_LT_BANG, + anon_sym_LT_SLASH, + sym_entity, + sym_text, + [397] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(89), 1, + anon_sym_LT, + ACTIONS(87), 5, + sym__implicit_end_tag, + anon_sym_LT_BANG, + anon_sym_LT_SLASH, + sym_entity, + sym_text, + [411] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(81), 1, + anon_sym_LT, + ACTIONS(79), 5, + ts_builtin_sym_end, + anon_sym_LT_BANG, + anon_sym_LT_SLASH, + sym_entity, + sym_text, + [425] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(93), 1, + anon_sym_LT, + ACTIONS(91), 5, + sym__implicit_end_tag, + anon_sym_LT_BANG, + anon_sym_LT_SLASH, + sym_entity, + sym_text, + [439] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(97), 1, + anon_sym_LT, + ACTIONS(95), 5, + sym__implicit_end_tag, + anon_sym_LT_BANG, + anon_sym_LT_SLASH, + sym_entity, + sym_text, + [453] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(73), 1, + anon_sym_LT, + ACTIONS(71), 5, + sym__implicit_end_tag, + anon_sym_LT_BANG, + anon_sym_LT_SLASH, + sym_entity, + sym_text, + [467] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(101), 1, + anon_sym_LT, + ACTIONS(99), 5, + ts_builtin_sym_end, + anon_sym_LT_BANG, + anon_sym_LT_SLASH, + sym_entity, + sym_text, + [481] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(69), 1, + anon_sym_LT, + ACTIONS(67), 5, + sym__implicit_end_tag, + anon_sym_LT_BANG, + anon_sym_LT_SLASH, + sym_entity, + sym_text, + [495] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(105), 1, + anon_sym_LT, + ACTIONS(103), 5, + ts_builtin_sym_end, + anon_sym_LT_BANG, + anon_sym_LT_SLASH, + sym_entity, + sym_text, + [509] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(109), 1, + anon_sym_LT, + ACTIONS(107), 5, + sym__implicit_end_tag, + anon_sym_LT_BANG, + anon_sym_LT_SLASH, + sym_entity, + sym_text, + [523] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(113), 1, + anon_sym_LT, + ACTIONS(111), 5, + sym__implicit_end_tag, + anon_sym_LT_BANG, + anon_sym_LT_SLASH, + sym_entity, + sym_text, + [537] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(117), 1, + anon_sym_LT, + ACTIONS(115), 5, + sym__implicit_end_tag, + anon_sym_LT_BANG, + anon_sym_LT_SLASH, + sym_entity, + sym_text, + [551] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(121), 1, + anon_sym_LT, + ACTIONS(119), 5, + ts_builtin_sym_end, + anon_sym_LT_BANG, + anon_sym_LT_SLASH, + sym_entity, + sym_text, + [565] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(93), 1, + anon_sym_LT, + ACTIONS(91), 5, + ts_builtin_sym_end, + anon_sym_LT_BANG, + anon_sym_LT_SLASH, + sym_entity, + sym_text, + [579] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(97), 1, + anon_sym_LT, + ACTIONS(95), 5, + ts_builtin_sym_end, + anon_sym_LT_BANG, + anon_sym_LT_SLASH, + sym_entity, + sym_text, + [593] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(121), 1, + anon_sym_LT, + ACTIONS(119), 5, + sym__implicit_end_tag, + anon_sym_LT_BANG, + anon_sym_LT_SLASH, + sym_entity, + sym_text, + [607] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(85), 1, + anon_sym_LT, + ACTIONS(83), 5, + sym__implicit_end_tag, + anon_sym_LT_BANG, + anon_sym_LT_SLASH, + sym_entity, + sym_text, + [621] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(101), 1, + anon_sym_LT, + ACTIONS(99), 5, + sym__implicit_end_tag, + anon_sym_LT_BANG, + anon_sym_LT_SLASH, + sym_entity, + sym_text, + [635] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(105), 1, + anon_sym_LT, + ACTIONS(103), 5, + sym__implicit_end_tag, + anon_sym_LT_BANG, + anon_sym_LT_SLASH, + sym_entity, + sym_text, + [649] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(113), 1, + anon_sym_LT, + ACTIONS(111), 5, + ts_builtin_sym_end, + anon_sym_LT_BANG, + anon_sym_LT_SLASH, + sym_entity, + sym_text, + [663] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(123), 1, + anon_sym_GT, + ACTIONS(125), 1, + anon_sym_SLASH_GT, + ACTIONS(127), 1, + sym_attribute_name, + STATE(38), 2, + sym_attribute, + aux_sym_start_tag_repeat1, + [680] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(127), 1, + sym_attribute_name, + ACTIONS(129), 1, + anon_sym_GT, + ACTIONS(131), 1, + anon_sym_SLASH_GT, + STATE(37), 2, + sym_attribute, + aux_sym_start_tag_repeat1, + [697] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(135), 1, + sym_attribute_name, + ACTIONS(133), 2, + anon_sym_GT, + anon_sym_SLASH_GT, + STATE(37), 2, + sym_attribute, + aux_sym_start_tag_repeat1, + [712] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(127), 1, + sym_attribute_name, + ACTIONS(129), 1, + anon_sym_GT, + ACTIONS(138), 1, + anon_sym_SLASH_GT, + STATE(37), 2, + sym_attribute, + aux_sym_start_tag_repeat1, + [729] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(123), 1, + anon_sym_GT, + ACTIONS(127), 1, + sym_attribute_name, + ACTIONS(140), 1, + anon_sym_SLASH_GT, + STATE(36), 2, + sym_attribute, + aux_sym_start_tag_repeat1, + [746] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(142), 1, + anon_sym_GT, + ACTIONS(144), 1, + sym_attribute_name, + STATE(47), 2, + sym_attribute, + aux_sym_start_tag_repeat1, + [760] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(144), 1, + sym_attribute_name, + ACTIONS(146), 1, + anon_sym_GT, + STATE(47), 2, + sym_attribute, + aux_sym_start_tag_repeat1, + [774] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(150), 1, + anon_sym_EQ, + ACTIONS(148), 3, + anon_sym_GT, + anon_sym_SLASH_GT, + sym_attribute_name, + [786] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(152), 1, + sym_attribute_value, + ACTIONS(154), 1, + anon_sym_SQUOTE, + ACTIONS(156), 1, + anon_sym_DQUOTE, + STATE(48), 1, + sym_quoted_attribute_value, + [802] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(158), 1, + sym_attribute_value, + ACTIONS(160), 1, + anon_sym_SQUOTE, + ACTIONS(162), 1, + anon_sym_DQUOTE, + STATE(69), 1, + sym_quoted_attribute_value, + [818] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(144), 1, + sym_attribute_name, + ACTIONS(164), 1, + anon_sym_GT, + STATE(40), 2, + sym_attribute, + aux_sym_start_tag_repeat1, + [832] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(144), 1, + sym_attribute_name, + ACTIONS(166), 1, + anon_sym_GT, + STATE(41), 2, + sym_attribute, + aux_sym_start_tag_repeat1, + [846] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(133), 1, + anon_sym_GT, + ACTIONS(168), 1, + sym_attribute_name, + STATE(47), 2, + sym_attribute, + aux_sym_start_tag_repeat1, + [860] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(171), 3, + anon_sym_GT, + anon_sym_SLASH_GT, + sym_attribute_name, + [869] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(173), 1, + anon_sym_EQ, + ACTIONS(148), 2, + anon_sym_GT, + sym_attribute_name, + [880] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(175), 3, + anon_sym_GT, + anon_sym_SLASH_GT, + sym_attribute_name, + [889] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(177), 1, + sym__start_tag_name, + ACTIONS(179), 1, + sym__script_start_tag_name, + ACTIONS(181), 1, + sym__style_start_tag_name, + [902] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(179), 1, + sym__script_start_tag_name, + ACTIONS(181), 1, + sym__style_start_tag_name, + ACTIONS(183), 1, + sym__start_tag_name, + [915] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(185), 3, + anon_sym_GT, + anon_sym_SLASH_GT, + sym_attribute_name, + [924] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(187), 1, + anon_sym_LT_SLASH, + ACTIONS(189), 1, + sym_raw_text, + STATE(21), 1, + sym_end_tag, + [937] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(191), 1, + anon_sym_LT_SLASH, + ACTIONS(193), 1, + sym_raw_text, + STATE(33), 1, + sym_end_tag, + [950] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(191), 1, + anon_sym_LT_SLASH, + ACTIONS(195), 1, + sym_raw_text, + STATE(32), 1, + sym_end_tag, + [963] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(187), 1, + anon_sym_LT_SLASH, + ACTIONS(197), 1, + sym_raw_text, + STATE(23), 1, + sym_end_tag, + [976] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(185), 2, + anon_sym_GT, + sym_attribute_name, + [984] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(199), 2, + sym_raw_text, + anon_sym_LT_SLASH, + [992] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(201), 2, + sym_raw_text, + anon_sym_LT_SLASH, + [1000] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(203), 2, + sym_raw_text, + anon_sym_LT_SLASH, + [1008] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(205), 1, + sym__end_tag_name, + ACTIONS(207), 1, + sym_erroneous_end_tag_name, + [1018] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(187), 1, + anon_sym_LT_SLASH, + STATE(29), 1, + sym_end_tag, + [1028] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(209), 1, + anon_sym_DQUOTE, + ACTIONS(211), 1, + aux_sym_quoted_attribute_value_token2, + [1038] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(187), 1, + anon_sym_LT_SLASH, + STATE(10), 1, + sym_end_tag, + [1048] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(207), 1, + sym_erroneous_end_tag_name, + ACTIONS(213), 1, + sym__end_tag_name, + [1058] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(209), 1, + anon_sym_SQUOTE, + ACTIONS(215), 1, + aux_sym_quoted_attribute_value_token1, + [1068] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(191), 1, + anon_sym_LT_SLASH, + STATE(19), 1, + sym_end_tag, + [1078] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(171), 2, + anon_sym_GT, + sym_attribute_name, + [1086] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(175), 2, + anon_sym_GT, + sym_attribute_name, + [1094] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(217), 1, + anon_sym_DQUOTE, + ACTIONS(219), 1, + aux_sym_quoted_attribute_value_token2, + [1104] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(191), 1, + anon_sym_LT_SLASH, + STATE(20), 1, + sym_end_tag, + [1114] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(221), 2, + sym_raw_text, + anon_sym_LT_SLASH, + [1122] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(217), 1, + anon_sym_SQUOTE, + ACTIONS(223), 1, + aux_sym_quoted_attribute_value_token1, + [1132] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(225), 1, + sym__doctype, + [1139] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(227), 1, + anon_sym_GT, + [1146] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(229), 1, + ts_builtin_sym_end, + [1153] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(231), 1, + anon_sym_SQUOTE, + [1160] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(233), 1, + aux_sym_doctype_token1, + [1167] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(235), 1, + anon_sym_GT, + [1174] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(237), 1, + sym_erroneous_end_tag_name, + [1181] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(239), 1, + anon_sym_GT, + [1188] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(241), 1, + anon_sym_GT, + [1195] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(243), 1, + anon_sym_GT, + [1202] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(213), 1, + sym__end_tag_name, + [1209] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(245), 1, + anon_sym_SQUOTE, + [1216] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(245), 1, + anon_sym_DQUOTE, + [1223] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(231), 1, + anon_sym_DQUOTE, + [1230] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(207), 1, + sym_erroneous_end_tag_name, + [1237] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(247), 1, + aux_sym_doctype_token1, + [1244] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(249), 1, + anon_sym_GT, + [1251] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(205), 1, + sym__end_tag_name, + [1258] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(251), 1, + sym__doctype, +}; + +static const uint32_t ts_small_parse_table_map[] = { + [SMALL_STATE(2)] = 0, + [SMALL_STATE(3)] = 44, + [SMALL_STATE(4)] = 88, + [SMALL_STATE(5)] = 132, + [SMALL_STATE(6)] = 176, + [SMALL_STATE(7)] = 217, + [SMALL_STATE(8)] = 258, + [SMALL_STATE(9)] = 299, + [SMALL_STATE(10)] = 313, + [SMALL_STATE(11)] = 327, + [SMALL_STATE(12)] = 341, + [SMALL_STATE(13)] = 355, + [SMALL_STATE(14)] = 369, + [SMALL_STATE(15)] = 383, + [SMALL_STATE(16)] = 397, + [SMALL_STATE(17)] = 411, + [SMALL_STATE(18)] = 425, + [SMALL_STATE(19)] = 439, + [SMALL_STATE(20)] = 453, + [SMALL_STATE(21)] = 467, + [SMALL_STATE(22)] = 481, + [SMALL_STATE(23)] = 495, + [SMALL_STATE(24)] = 509, + [SMALL_STATE(25)] = 523, + [SMALL_STATE(26)] = 537, + [SMALL_STATE(27)] = 551, + [SMALL_STATE(28)] = 565, + [SMALL_STATE(29)] = 579, + [SMALL_STATE(30)] = 593, + [SMALL_STATE(31)] = 607, + [SMALL_STATE(32)] = 621, + [SMALL_STATE(33)] = 635, + [SMALL_STATE(34)] = 649, + [SMALL_STATE(35)] = 663, + [SMALL_STATE(36)] = 680, + [SMALL_STATE(37)] = 697, + [SMALL_STATE(38)] = 712, + [SMALL_STATE(39)] = 729, + [SMALL_STATE(40)] = 746, + [SMALL_STATE(41)] = 760, + [SMALL_STATE(42)] = 774, + [SMALL_STATE(43)] = 786, + [SMALL_STATE(44)] = 802, + [SMALL_STATE(45)] = 818, + [SMALL_STATE(46)] = 832, + [SMALL_STATE(47)] = 846, + [SMALL_STATE(48)] = 860, + [SMALL_STATE(49)] = 869, + [SMALL_STATE(50)] = 880, + [SMALL_STATE(51)] = 889, + [SMALL_STATE(52)] = 902, + [SMALL_STATE(53)] = 915, + [SMALL_STATE(54)] = 924, + [SMALL_STATE(55)] = 937, + [SMALL_STATE(56)] = 950, + [SMALL_STATE(57)] = 963, + [SMALL_STATE(58)] = 976, + [SMALL_STATE(59)] = 984, + [SMALL_STATE(60)] = 992, + [SMALL_STATE(61)] = 1000, + [SMALL_STATE(62)] = 1008, + [SMALL_STATE(63)] = 1018, + [SMALL_STATE(64)] = 1028, + [SMALL_STATE(65)] = 1038, + [SMALL_STATE(66)] = 1048, + [SMALL_STATE(67)] = 1058, + [SMALL_STATE(68)] = 1068, + [SMALL_STATE(69)] = 1078, + [SMALL_STATE(70)] = 1086, + [SMALL_STATE(71)] = 1094, + [SMALL_STATE(72)] = 1104, + [SMALL_STATE(73)] = 1114, + [SMALL_STATE(74)] = 1122, + [SMALL_STATE(75)] = 1132, + [SMALL_STATE(76)] = 1139, + [SMALL_STATE(77)] = 1146, + [SMALL_STATE(78)] = 1153, + [SMALL_STATE(79)] = 1160, + [SMALL_STATE(80)] = 1167, + [SMALL_STATE(81)] = 1174, + [SMALL_STATE(82)] = 1181, + [SMALL_STATE(83)] = 1188, + [SMALL_STATE(84)] = 1195, + [SMALL_STATE(85)] = 1202, + [SMALL_STATE(86)] = 1209, + [SMALL_STATE(87)] = 1216, + [SMALL_STATE(88)] = 1223, + [SMALL_STATE(89)] = 1230, + [SMALL_STATE(90)] = 1237, + [SMALL_STATE(91)] = 1244, + [SMALL_STATE(92)] = 1251, + [SMALL_STATE(93)] = 1258, +}; + +static const TSParseActionEntry ts_parse_actions[] = { + [0] = {.entry = {.count = 0, .reusable = false}}, + [1] = {.entry = {.count = 1, .reusable = false}}, RECOVER(), + [3] = {.entry = {.count = 1, .reusable = true}}, SHIFT_EXTRA(), + [5] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_document, 0, 0, 0), + [7] = {.entry = {.count = 1, .reusable = true}}, SHIFT(75), + [9] = {.entry = {.count = 1, .reusable = false}}, SHIFT(52), + [11] = {.entry = {.count = 1, .reusable = true}}, SHIFT(81), + [13] = {.entry = {.count = 1, .reusable = true}}, SHIFT(8), + [15] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93), + [17] = {.entry = {.count = 1, .reusable = false}}, SHIFT(51), + [19] = {.entry = {.count = 1, .reusable = true}}, SHIFT(66), + [21] = {.entry = {.count = 1, .reusable = true}}, SHIFT(6), + [23] = {.entry = {.count = 1, .reusable = true}}, SHIFT(9), + [25] = {.entry = {.count = 1, .reusable = true}}, SHIFT(62), + [27] = {.entry = {.count = 1, .reusable = true}}, SHIFT(22), + [29] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2), + [31] = {.entry = {.count = 1, .reusable = true}}, SHIFT(17), + [33] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3), + [35] = {.entry = {.count = 1, .reusable = true}}, SHIFT(12), + [37] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_document_repeat1, 2, 0, 0), SHIFT_REPEAT(93), + [40] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_document_repeat1, 2, 0, 0), SHIFT_REPEAT(51), + [43] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_document_repeat1, 2, 0, 0), SHIFT_REPEAT(89), + [46] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_document_repeat1, 2, 0, 0), SHIFT_REPEAT(6), + [49] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_document_repeat1, 2, 0, 0), + [51] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_document_repeat1, 2, 0, 0), SHIFT_REPEAT(75), + [54] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_document_repeat1, 2, 0, 0), SHIFT_REPEAT(52), + [57] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_document_repeat1, 2, 0, 0), SHIFT_REPEAT(81), + [60] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_document_repeat1, 2, 0, 0), SHIFT_REPEAT(7), + [63] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_document, 1, 0, 0), + [65] = {.entry = {.count = 1, .reusable = true}}, SHIFT(7), + [67] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_element, 3, 0, 0), + [69] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_element, 3, 0, 0), + [71] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_script_element, 3, 0, 0), + [73] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_script_element, 3, 0, 0), + [75] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_element, 1, 0, 0), + [77] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_element, 1, 0, 0), + [79] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_element, 2, 0, 0), + [81] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_element, 2, 0, 0), + [83] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_end_tag, 3, 0, 0), + [85] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_end_tag, 3, 0, 0), + [87] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_self_closing_tag, 4, 0, 0), + [89] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_self_closing_tag, 4, 0, 0), + [91] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_doctype, 4, 0, 0), + [93] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_doctype, 4, 0, 0), + [95] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_style_element, 3, 0, 0), + [97] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_style_element, 3, 0, 0), + [99] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_script_element, 2, 0, 0), + [101] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_script_element, 2, 0, 0), + [103] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_style_element, 2, 0, 0), + [105] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_style_element, 2, 0, 0), + [107] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_start_tag, 4, 0, 0), + [109] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_start_tag, 4, 0, 0), + [111] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_erroneous_end_tag, 3, 0, 0), + [113] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_erroneous_end_tag, 3, 0, 0), + [115] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_start_tag, 3, 0, 0), + [117] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_start_tag, 3, 0, 0), + [119] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_self_closing_tag, 3, 0, 0), + [121] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_self_closing_tag, 3, 0, 0), + [123] = {.entry = {.count = 1, .reusable = true}}, SHIFT(26), + [125] = {.entry = {.count = 1, .reusable = true}}, SHIFT(30), + [127] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42), + [129] = {.entry = {.count = 1, .reusable = true}}, SHIFT(24), + [131] = {.entry = {.count = 1, .reusable = true}}, SHIFT(15), + [133] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_start_tag_repeat1, 2, 0, 0), + [135] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_start_tag_repeat1, 2, 0, 0), SHIFT_REPEAT(42), + [138] = {.entry = {.count = 1, .reusable = true}}, SHIFT(16), + [140] = {.entry = {.count = 1, .reusable = true}}, SHIFT(27), + [142] = {.entry = {.count = 1, .reusable = true}}, SHIFT(73), + [144] = {.entry = {.count = 1, .reusable = true}}, SHIFT(49), + [146] = {.entry = {.count = 1, .reusable = true}}, SHIFT(59), + [148] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_attribute, 1, 0, 0), + [150] = {.entry = {.count = 1, .reusable = true}}, SHIFT(43), + [152] = {.entry = {.count = 1, .reusable = true}}, SHIFT(48), + [154] = {.entry = {.count = 1, .reusable = true}}, SHIFT(74), + [156] = {.entry = {.count = 1, .reusable = true}}, SHIFT(71), + [158] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69), + [160] = {.entry = {.count = 1, .reusable = true}}, SHIFT(67), + [162] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64), + [164] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60), + [166] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61), + [168] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_start_tag_repeat1, 2, 0, 0), SHIFT_REPEAT(49), + [171] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_attribute, 3, 0, 0), + [173] = {.entry = {.count = 1, .reusable = true}}, SHIFT(44), + [175] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_quoted_attribute_value, 2, 0, 0), + [177] = {.entry = {.count = 1, .reusable = true}}, SHIFT(35), + [179] = {.entry = {.count = 1, .reusable = true}}, SHIFT(46), + [181] = {.entry = {.count = 1, .reusable = true}}, SHIFT(45), + [183] = {.entry = {.count = 1, .reusable = true}}, SHIFT(39), + [185] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_quoted_attribute_value, 3, 0, 0), + [187] = {.entry = {.count = 1, .reusable = true}}, SHIFT(85), + [189] = {.entry = {.count = 1, .reusable = true}}, SHIFT(65), + [191] = {.entry = {.count = 1, .reusable = true}}, SHIFT(92), + [193] = {.entry = {.count = 1, .reusable = true}}, SHIFT(68), + [195] = {.entry = {.count = 1, .reusable = true}}, SHIFT(72), + [197] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63), + [199] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_script_start_tag, 4, 0, 0), + [201] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_style_start_tag, 3, 0, 0), + [203] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_script_start_tag, 3, 0, 0), + [205] = {.entry = {.count = 1, .reusable = true}}, SHIFT(82), + [207] = {.entry = {.count = 1, .reusable = true}}, SHIFT(76), + [209] = {.entry = {.count = 1, .reusable = false}}, SHIFT(70), + [211] = {.entry = {.count = 1, .reusable = true}}, SHIFT(87), + [213] = {.entry = {.count = 1, .reusable = true}}, SHIFT(83), + [215] = {.entry = {.count = 1, .reusable = true}}, SHIFT(86), + [217] = {.entry = {.count = 1, .reusable = false}}, SHIFT(50), + [219] = {.entry = {.count = 1, .reusable = true}}, SHIFT(88), + [221] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_style_start_tag, 4, 0, 0), + [223] = {.entry = {.count = 1, .reusable = true}}, SHIFT(78), + [225] = {.entry = {.count = 1, .reusable = true}}, SHIFT(79), + [227] = {.entry = {.count = 1, .reusable = true}}, SHIFT(25), + [229] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), + [231] = {.entry = {.count = 1, .reusable = true}}, SHIFT(53), + [233] = {.entry = {.count = 1, .reusable = true}}, SHIFT(91), + [235] = {.entry = {.count = 1, .reusable = true}}, SHIFT(18), + [237] = {.entry = {.count = 1, .reusable = true}}, SHIFT(84), + [239] = {.entry = {.count = 1, .reusable = true}}, SHIFT(31), + [241] = {.entry = {.count = 1, .reusable = true}}, SHIFT(14), + [243] = {.entry = {.count = 1, .reusable = true}}, SHIFT(34), + [245] = {.entry = {.count = 1, .reusable = true}}, SHIFT(58), + [247] = {.entry = {.count = 1, .reusable = true}}, SHIFT(80), + [249] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28), + [251] = {.entry = {.count = 1, .reusable = true}}, SHIFT(90), +}; + +enum ts_external_scanner_symbol_identifiers { + ts_external_token__start_tag_name = 0, + ts_external_token__script_start_tag_name = 1, + ts_external_token__style_start_tag_name = 2, + ts_external_token__end_tag_name = 3, + ts_external_token_erroneous_end_tag_name = 4, + ts_external_token_SLASH_GT = 5, + ts_external_token__implicit_end_tag = 6, + ts_external_token_raw_text = 7, + ts_external_token_comment = 8, +}; + +static const TSSymbol ts_external_scanner_symbol_map[EXTERNAL_TOKEN_COUNT] = { + [ts_external_token__start_tag_name] = sym__start_tag_name, + [ts_external_token__script_start_tag_name] = sym__script_start_tag_name, + [ts_external_token__style_start_tag_name] = sym__style_start_tag_name, + [ts_external_token__end_tag_name] = sym__end_tag_name, + [ts_external_token_erroneous_end_tag_name] = sym_erroneous_end_tag_name, + [ts_external_token_SLASH_GT] = anon_sym_SLASH_GT, + [ts_external_token__implicit_end_tag] = sym__implicit_end_tag, + [ts_external_token_raw_text] = sym_raw_text, + [ts_external_token_comment] = sym_comment, +}; + +static const bool ts_external_scanner_states[10][EXTERNAL_TOKEN_COUNT] = { + [1] = { + [ts_external_token__start_tag_name] = true, + [ts_external_token__script_start_tag_name] = true, + [ts_external_token__style_start_tag_name] = true, + [ts_external_token__end_tag_name] = true, + [ts_external_token_erroneous_end_tag_name] = true, + [ts_external_token_SLASH_GT] = true, + [ts_external_token__implicit_end_tag] = true, + [ts_external_token_raw_text] = true, + [ts_external_token_comment] = true, + }, + [2] = { + [ts_external_token_comment] = true, + }, + [3] = { + [ts_external_token__implicit_end_tag] = true, + [ts_external_token_comment] = true, + }, + [4] = { + [ts_external_token_SLASH_GT] = true, + [ts_external_token_comment] = true, + }, + [5] = { + [ts_external_token__start_tag_name] = true, + [ts_external_token__script_start_tag_name] = true, + [ts_external_token__style_start_tag_name] = true, + [ts_external_token_comment] = true, + }, + [6] = { + [ts_external_token_raw_text] = true, + [ts_external_token_comment] = true, + }, + [7] = { + [ts_external_token__end_tag_name] = true, + [ts_external_token_erroneous_end_tag_name] = true, + [ts_external_token_comment] = true, + }, + [8] = { + [ts_external_token_erroneous_end_tag_name] = true, + [ts_external_token_comment] = true, + }, + [9] = { + [ts_external_token__end_tag_name] = true, + [ts_external_token_comment] = true, + }, +}; + +#ifdef __cplusplus +extern "C" { +#endif +void *tree_sitter_html_external_scanner_create(void); +void tree_sitter_html_external_scanner_destroy(void *); +bool tree_sitter_html_external_scanner_scan(void *, TSLexer *, const bool *); +unsigned tree_sitter_html_external_scanner_serialize(void *, char *); +void tree_sitter_html_external_scanner_deserialize(void *, const char *, unsigned); + +#ifdef TREE_SITTER_HIDE_SYMBOLS +#define TS_PUBLIC +#elif defined(_WIN32) +#define TS_PUBLIC __declspec(dllexport) +#else +#define TS_PUBLIC __attribute__((visibility("default"))) +#endif + +TS_PUBLIC const TSLanguage *tree_sitter_html(void) { + static const TSLanguage language = { + .version = LANGUAGE_VERSION, + .symbol_count = SYMBOL_COUNT, + .alias_count = ALIAS_COUNT, + .token_count = TOKEN_COUNT, + .external_token_count = EXTERNAL_TOKEN_COUNT, + .state_count = STATE_COUNT, + .large_state_count = LARGE_STATE_COUNT, + .production_id_count = PRODUCTION_ID_COUNT, + .field_count = FIELD_COUNT, + .max_alias_sequence_length = MAX_ALIAS_SEQUENCE_LENGTH, + .parse_table = &ts_parse_table[0][0], + .small_parse_table = ts_small_parse_table, + .small_parse_table_map = ts_small_parse_table_map, + .parse_actions = ts_parse_actions, + .symbol_names = ts_symbol_names, + .symbol_metadata = ts_symbol_metadata, + .public_symbol_map = ts_symbol_map, + .alias_map = ts_non_terminal_alias_map, + .alias_sequences = &ts_alias_sequences[0][0], + .lex_modes = ts_lex_modes, + .lex_fn = ts_lex, + .external_scanner = { + &ts_external_scanner_states[0][0], + ts_external_scanner_symbol_map, + tree_sitter_html_external_scanner_create, + tree_sitter_html_external_scanner_destroy, + tree_sitter_html_external_scanner_scan, + tree_sitter_html_external_scanner_serialize, + tree_sitter_html_external_scanner_deserialize, + }, + .primary_state_ids = ts_primary_state_ids, + }; + return &language; +} +#ifdef __cplusplus +} +#endif diff --git a/vendor/github.com/mitjafelicijan/go-tree-sitter/html/parser.h b/vendor/github.com/mitjafelicijan/go-tree-sitter/html/parser.h new file mode 100644 index 0000000..17f0e94 --- /dev/null +++ b/vendor/github.com/mitjafelicijan/go-tree-sitter/html/parser.h @@ -0,0 +1,265 @@ +#ifndef TREE_SITTER_PARSER_H_ +#define TREE_SITTER_PARSER_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include + +#define ts_builtin_sym_error ((TSSymbol)-1) +#define ts_builtin_sym_end 0 +#define TREE_SITTER_SERIALIZATION_BUFFER_SIZE 1024 + +#ifndef TREE_SITTER_API_H_ +typedef uint16_t TSStateId; +typedef uint16_t TSSymbol; +typedef uint16_t TSFieldId; +typedef struct TSLanguage TSLanguage; +#endif + +typedef struct { + TSFieldId field_id; + uint8_t child_index; + bool inherited; +} TSFieldMapEntry; + +typedef struct { + uint16_t index; + uint16_t length; +} TSFieldMapSlice; + +typedef struct { + bool visible; + bool named; + bool supertype; +} TSSymbolMetadata; + +typedef struct TSLexer TSLexer; + +struct TSLexer { + int32_t lookahead; + TSSymbol result_symbol; + void (*advance)(TSLexer *, bool); + void (*mark_end)(TSLexer *); + uint32_t (*get_column)(TSLexer *); + bool (*is_at_included_range_start)(const TSLexer *); + bool (*eof)(const TSLexer *); +}; + +typedef enum { + TSParseActionTypeShift, + TSParseActionTypeReduce, + TSParseActionTypeAccept, + TSParseActionTypeRecover, +} TSParseActionType; + +typedef union { + struct { + uint8_t type; + TSStateId state; + bool extra; + bool repetition; + } shift; + struct { + uint8_t type; + uint8_t child_count; + TSSymbol symbol; + int16_t dynamic_precedence; + uint16_t production_id; + } reduce; + uint8_t type; +} TSParseAction; + +typedef struct { + uint16_t lex_state; + uint16_t external_lex_state; +} TSLexMode; + +typedef union { + TSParseAction action; + struct { + uint8_t count; + bool reusable; + } entry; +} TSParseActionEntry; + +typedef struct { + int32_t start; + int32_t end; +} TSCharacterRange; + +struct TSLanguage { + uint32_t version; + uint32_t symbol_count; + uint32_t alias_count; + uint32_t token_count; + uint32_t external_token_count; + uint32_t state_count; + uint32_t large_state_count; + uint32_t production_id_count; + uint32_t field_count; + uint16_t max_alias_sequence_length; + const uint16_t *parse_table; + const uint16_t *small_parse_table; + const uint32_t *small_parse_table_map; + const TSParseActionEntry *parse_actions; + const char * const *symbol_names; + const char * const *field_names; + const TSFieldMapSlice *field_map_slices; + const TSFieldMapEntry *field_map_entries; + const TSSymbolMetadata *symbol_metadata; + const TSSymbol *public_symbol_map; + const uint16_t *alias_map; + const TSSymbol *alias_sequences; + const TSLexMode *lex_modes; + bool (*lex_fn)(TSLexer *, TSStateId); + bool (*keyword_lex_fn)(TSLexer *, TSStateId); + TSSymbol keyword_capture_token; + struct { + const bool *states; + const TSSymbol *symbol_map; + void *(*create)(void); + void (*destroy)(void *); + bool (*scan)(void *, TSLexer *, const bool *symbol_whitelist); + unsigned (*serialize)(void *, char *); + void (*deserialize)(void *, const char *, unsigned); + } external_scanner; + const TSStateId *primary_state_ids; +}; + +static inline bool set_contains(TSCharacterRange *ranges, uint32_t len, int32_t lookahead) { + uint32_t index = 0; + uint32_t size = len - index; + while (size > 1) { + uint32_t half_size = size / 2; + uint32_t mid_index = index + half_size; + TSCharacterRange *range = &ranges[mid_index]; + if (lookahead >= range->start && lookahead <= range->end) { + return true; + } else if (lookahead > range->end) { + index = mid_index; + } + size -= half_size; + } + TSCharacterRange *range = &ranges[index]; + return (lookahead >= range->start && lookahead <= range->end); +} + +/* + * Lexer Macros + */ + +#ifdef _MSC_VER +#define UNUSED __pragma(warning(suppress : 4101)) +#else +#define UNUSED __attribute__((unused)) +#endif + +#define START_LEXER() \ + bool result = false; \ + bool skip = false; \ + UNUSED \ + bool eof = false; \ + int32_t lookahead; \ + goto start; \ + next_state: \ + lexer->advance(lexer, skip); \ + start: \ + skip = false; \ + lookahead = lexer->lookahead; + +#define ADVANCE(state_value) \ + { \ + state = state_value; \ + goto next_state; \ + } + +#define ADVANCE_MAP(...) \ + { \ + static const uint16_t map[] = { __VA_ARGS__ }; \ + for (uint32_t i = 0; i < sizeof(map) / sizeof(map[0]); i += 2) { \ + if (map[i] == lookahead) { \ + state = map[i + 1]; \ + goto next_state; \ + } \ + } \ + } + +#define SKIP(state_value) \ + { \ + skip = true; \ + state = state_value; \ + goto next_state; \ + } + +#define ACCEPT_TOKEN(symbol_value) \ + result = true; \ + lexer->result_symbol = symbol_value; \ + lexer->mark_end(lexer); + +#define END_STATE() return result; + +/* + * Parse Table Macros + */ + +#define SMALL_STATE(id) ((id) - LARGE_STATE_COUNT) + +#define STATE(id) id + +#define ACTIONS(id) id + +#define SHIFT(state_value) \ + {{ \ + .shift = { \ + .type = TSParseActionTypeShift, \ + .state = (state_value) \ + } \ + }} + +#define SHIFT_REPEAT(state_value) \ + {{ \ + .shift = { \ + .type = TSParseActionTypeShift, \ + .state = (state_value), \ + .repetition = true \ + } \ + }} + +#define SHIFT_EXTRA() \ + {{ \ + .shift = { \ + .type = TSParseActionTypeShift, \ + .extra = true \ + } \ + }} + +#define REDUCE(symbol_name, children, precedence, prod_id) \ + {{ \ + .reduce = { \ + .type = TSParseActionTypeReduce, \ + .symbol = symbol_name, \ + .child_count = children, \ + .dynamic_precedence = precedence, \ + .production_id = prod_id \ + }, \ + }} + +#define RECOVER() \ + {{ \ + .type = TSParseActionTypeRecover \ + }} + +#define ACCEPT_INPUT() \ + {{ \ + .type = TSParseActionTypeAccept \ + }} + +#ifdef __cplusplus +} +#endif + +#endif // TREE_SITTER_PARSER_H_ diff --git a/vendor/github.com/mitjafelicijan/go-tree-sitter/html/scanner.c b/vendor/github.com/mitjafelicijan/go-tree-sitter/html/scanner.c new file mode 100644 index 0000000..d14ba9b --- /dev/null +++ b/vendor/github.com/mitjafelicijan/go-tree-sitter/html/scanner.c @@ -0,0 +1,362 @@ +#include "tag.h" +#include "parser.h" + +#include + +enum TokenType { + START_TAG_NAME, + SCRIPT_START_TAG_NAME, + STYLE_START_TAG_NAME, + END_TAG_NAME, + ERRONEOUS_END_TAG_NAME, + SELF_CLOSING_TAG_DELIMITER, + IMPLICIT_END_TAG, + RAW_TEXT, + COMMENT, +}; + +typedef struct { + Array(Tag) tags; +} Scanner; + +#define MAX(a, b) ((a) > (b) ? (a) : (b)) + +static inline void advance(TSLexer *lexer) { lexer->advance(lexer, false); } + +static inline void skip(TSLexer *lexer) { lexer->advance(lexer, true); } + +static unsigned serialize(Scanner *scanner, char *buffer) { + uint16_t tag_count = scanner->tags.size > UINT16_MAX ? UINT16_MAX : scanner->tags.size; + uint16_t serialized_tag_count = 0; + + unsigned size = sizeof(tag_count); + memcpy(&buffer[size], &tag_count, sizeof(tag_count)); + size += sizeof(tag_count); + + for (; serialized_tag_count < tag_count; serialized_tag_count++) { + Tag tag = scanner->tags.contents[serialized_tag_count]; + if (tag.type == CUSTOM) { + unsigned name_length = tag.custom_tag_name.size; + if (name_length > UINT8_MAX) { + name_length = UINT8_MAX; + } + if (size + 2 + name_length >= TREE_SITTER_SERIALIZATION_BUFFER_SIZE) { + break; + } + buffer[size++] = (char)tag.type; + buffer[size++] = (char)name_length; + strncpy(&buffer[size], tag.custom_tag_name.contents, name_length); + size += name_length; + } else { + if (size + 1 >= TREE_SITTER_SERIALIZATION_BUFFER_SIZE) { + break; + } + buffer[size++] = (char)tag.type; + } + } + + memcpy(&buffer[0], &serialized_tag_count, sizeof(serialized_tag_count)); + return size; +} + +static void deserialize(Scanner *scanner, const char *buffer, unsigned length) { + for (unsigned i = 0; i < scanner->tags.size; i++) { + tag_free(&scanner->tags.contents[i]); + } + array_clear(&scanner->tags); + + if (length > 0) { + unsigned size = 0; + uint16_t tag_count = 0; + uint16_t serialized_tag_count = 0; + + memcpy(&serialized_tag_count, &buffer[size], sizeof(serialized_tag_count)); + size += sizeof(serialized_tag_count); + + memcpy(&tag_count, &buffer[size], sizeof(tag_count)); + size += sizeof(tag_count); + + array_reserve(&scanner->tags, tag_count); + if (tag_count > 0) { + unsigned iter = 0; + for (iter = 0; iter < serialized_tag_count; iter++) { + Tag tag = tag_new(); + tag.type = (TagType)buffer[size++]; + if (tag.type == CUSTOM) { + uint16_t name_length = (uint8_t)buffer[size++]; + array_reserve(&tag.custom_tag_name, name_length); + tag.custom_tag_name.size = name_length; + memcpy(tag.custom_tag_name.contents, &buffer[size], name_length); + size += name_length; + } + array_push(&scanner->tags, tag); + } + // add zero tags if we didn't read enough, this is because the + // buffer had no more room but we held more tags. + for (; iter < tag_count; iter++) { + array_push(&scanner->tags, tag_new()); + } + } + } +} + +static String scan_tag_name(TSLexer *lexer) { + String tag_name = array_new(); + while (iswalnum(lexer->lookahead) || lexer->lookahead == '-' || lexer->lookahead == ':') { + array_push(&tag_name, towupper(lexer->lookahead)); + advance(lexer); + } + return tag_name; +} + +static bool scan_comment(TSLexer *lexer) { + if (lexer->lookahead != '-') { + return false; + } + advance(lexer); + if (lexer->lookahead != '-') { + return false; + } + advance(lexer); + + unsigned dashes = 0; + while (lexer->lookahead) { + switch (lexer->lookahead) { + case '-': + ++dashes; + break; + case '>': + if (dashes >= 2) { + lexer->result_symbol = COMMENT; + advance(lexer); + lexer->mark_end(lexer); + return true; + } + default: + dashes = 0; + } + advance(lexer); + } + return false; +} + +static bool scan_raw_text(Scanner *scanner, TSLexer *lexer) { + if (scanner->tags.size == 0) { + return false; + } + + lexer->mark_end(lexer); + + const char *end_delimiter = array_back(&scanner->tags)->type == SCRIPT ? "lookahead) { + if (towupper(lexer->lookahead) == end_delimiter[delimiter_index]) { + delimiter_index++; + if (delimiter_index == strlen(end_delimiter)) { + break; + } + advance(lexer); + } else { + delimiter_index = 0; + advance(lexer); + lexer->mark_end(lexer); + } + } + + lexer->result_symbol = RAW_TEXT; + return true; +} + +static void pop_tag(Scanner *scanner) { + Tag popped_tag = array_pop(&scanner->tags); + tag_free(&popped_tag); +} + +static bool scan_implicit_end_tag(Scanner *scanner, TSLexer *lexer) { + Tag *parent = scanner->tags.size == 0 ? NULL : array_back(&scanner->tags); + + bool is_closing_tag = false; + if (lexer->lookahead == '/') { + is_closing_tag = true; + advance(lexer); + } else { + if (parent && tag_is_void(parent)) { + pop_tag(scanner); + lexer->result_symbol = IMPLICIT_END_TAG; + return true; + } + } + + String tag_name = scan_tag_name(lexer); + if (tag_name.size == 0 && !lexer->eof(lexer)) { + array_delete(&tag_name); + return false; + } + + Tag next_tag = tag_for_name(tag_name); + + if (is_closing_tag) { + // The tag correctly closes the topmost element on the stack + if (scanner->tags.size > 0 && tag_eq(array_back(&scanner->tags), &next_tag)) { + tag_free(&next_tag); + return false; + } + + // Otherwise, dig deeper and queue implicit end tags (to be nice in + // the case of malformed HTML) + for (unsigned i = scanner->tags.size; i > 0; i--) { + if (scanner->tags.contents[i - 1].type == next_tag.type) { + pop_tag(scanner); + lexer->result_symbol = IMPLICIT_END_TAG; + tag_free(&next_tag); + return true; + } + } + } else if ( + parent && + ( + !tag_can_contain(parent, &next_tag) || + ((parent->type == HTML || parent->type == HEAD || parent->type == BODY) && lexer->eof(lexer)) + ) + ) { + pop_tag(scanner); + lexer->result_symbol = IMPLICIT_END_TAG; + tag_free(&next_tag); + return true; + } + + tag_free(&next_tag); + return false; +} + +static bool scan_start_tag_name(Scanner *scanner, TSLexer *lexer) { + String tag_name = scan_tag_name(lexer); + if (tag_name.size == 0) { + array_delete(&tag_name); + return false; + } + + Tag tag = tag_for_name(tag_name); + array_push(&scanner->tags, tag); + switch (tag.type) { + case SCRIPT: + lexer->result_symbol = SCRIPT_START_TAG_NAME; + break; + case STYLE: + lexer->result_symbol = STYLE_START_TAG_NAME; + break; + default: + lexer->result_symbol = START_TAG_NAME; + break; + } + return true; +} + +static bool scan_end_tag_name(Scanner *scanner, TSLexer *lexer) { + String tag_name = scan_tag_name(lexer); + + if (tag_name.size == 0) { + array_delete(&tag_name); + return false; + } + + Tag tag = tag_for_name(tag_name); + if (scanner->tags.size > 0 && tag_eq(array_back(&scanner->tags), &tag)) { + pop_tag(scanner); + lexer->result_symbol = END_TAG_NAME; + } else { + lexer->result_symbol = ERRONEOUS_END_TAG_NAME; + } + + tag_free(&tag); + return true; +} + +static bool scan_self_closing_tag_delimiter(Scanner *scanner, TSLexer *lexer) { + advance(lexer); + if (lexer->lookahead == '>') { + advance(lexer); + if (scanner->tags.size > 0) { + pop_tag(scanner); + lexer->result_symbol = SELF_CLOSING_TAG_DELIMITER; + } + return true; + } + return false; +} + +static bool scan(Scanner *scanner, TSLexer *lexer, const bool *valid_symbols) { + if (valid_symbols[RAW_TEXT] && !valid_symbols[START_TAG_NAME] && !valid_symbols[END_TAG_NAME]) { + return scan_raw_text(scanner, lexer); + } + + while (iswspace(lexer->lookahead)) { + skip(lexer); + } + + switch (lexer->lookahead) { + case '<': + lexer->mark_end(lexer); + advance(lexer); + + if (lexer->lookahead == '!') { + advance(lexer); + return scan_comment(lexer); + } + + if (valid_symbols[IMPLICIT_END_TAG]) { + return scan_implicit_end_tag(scanner, lexer); + } + break; + + case '\0': + if (valid_symbols[IMPLICIT_END_TAG]) { + return scan_implicit_end_tag(scanner, lexer); + } + break; + + case '/': + if (valid_symbols[SELF_CLOSING_TAG_DELIMITER]) { + return scan_self_closing_tag_delimiter(scanner, lexer); + } + break; + + default: + if ((valid_symbols[START_TAG_NAME] || valid_symbols[END_TAG_NAME]) && !valid_symbols[RAW_TEXT]) { + return valid_symbols[START_TAG_NAME] ? scan_start_tag_name(scanner, lexer) + : scan_end_tag_name(scanner, lexer); + } + } + + return false; +} + +void *tree_sitter_html_external_scanner_create() { + Scanner *scanner = (Scanner *)ts_calloc(1, sizeof(Scanner)); + return scanner; +} + +bool tree_sitter_html_external_scanner_scan(void *payload, TSLexer *lexer, const bool *valid_symbols) { + Scanner *scanner = (Scanner *)payload; + return scan(scanner, lexer, valid_symbols); +} + +unsigned tree_sitter_html_external_scanner_serialize(void *payload, char *buffer) { + Scanner *scanner = (Scanner *)payload; + return serialize(scanner, buffer); +} + +void tree_sitter_html_external_scanner_deserialize(void *payload, const char *buffer, unsigned length) { + Scanner *scanner = (Scanner *)payload; + deserialize(scanner, buffer, length); +} + +void tree_sitter_html_external_scanner_destroy(void *payload) { + Scanner *scanner = (Scanner *)payload; + for (unsigned i = 0; i < scanner->tags.size; i++) { + tag_free(&scanner->tags.contents[i]); + } + array_delete(&scanner->tags); + ts_free(scanner); +} diff --git a/vendor/github.com/mitjafelicijan/go-tree-sitter/html/tag.h b/vendor/github.com/mitjafelicijan/go-tree-sitter/html/tag.h new file mode 100644 index 0000000..ca56abd --- /dev/null +++ b/vendor/github.com/mitjafelicijan/go-tree-sitter/html/tag.h @@ -0,0 +1,385 @@ +#include "../array.h" + +#include + +typedef enum { + AREA, + BASE, + BASEFONT, + BGSOUND, + BR, + COL, + COMMAND, + EMBED, + FRAME, + HR, + IMAGE, + IMG, + INPUT, + ISINDEX, + KEYGEN, + LINK, + MENUITEM, + META, + NEXTID, + PARAM, + SOURCE, + TRACK, + WBR, + END_OF_VOID_TAGS, + + A, + ABBR, + ADDRESS, + ARTICLE, + ASIDE, + AUDIO, + B, + BDI, + BDO, + BLOCKQUOTE, + BODY, + BUTTON, + CANVAS, + CAPTION, + CITE, + CODE, + COLGROUP, + DATA, + DATALIST, + DD, + DEL, + DETAILS, + DFN, + DIALOG, + DIV, + DL, + DT, + EM, + FIELDSET, + FIGCAPTION, + FIGURE, + FOOTER, + FORM, + H1, + H2, + H3, + H4, + H5, + H6, + HEAD, + HEADER, + HGROUP, + HTML, + I, + IFRAME, + INS, + KBD, + LABEL, + LEGEND, + LI, + MAIN, + MAP, + MARK, + MATH, + MENU, + METER, + NAV, + NOSCRIPT, + OBJECT, + OL, + OPTGROUP, + OPTION, + OUTPUT, + P, + PICTURE, + PRE, + PROGRESS, + Q, + RB, + RP, + RT, + RTC, + RUBY, + S, + SAMP, + SCRIPT, + SECTION, + SELECT, + SLOT, + SMALL, + SPAN, + STRONG, + STYLE, + SUB, + SUMMARY, + SUP, + SVG, + TABLE, + TBODY, + TD, + TEMPLATE, + TEXTAREA, + TFOOT, + TH, + THEAD, + TIME, + TITLE, + TR, + U, + UL, + VAR, + VIDEO, + + CUSTOM, + + END_, +} TagType; + +typedef Array(char) String; + +typedef struct { + char tag_name[16]; + TagType tag_type; +} TagMapEntry; + +typedef struct { + TagType type; + String custom_tag_name; +} Tag; + +static const TagMapEntry TAG_TYPES_BY_TAG_NAME[126] = { + {"AREA", AREA }, + {"BASE", BASE }, + {"BASEFONT", BASEFONT }, + {"BGSOUND", BGSOUND }, + {"BR", BR }, + {"COL", COL }, + {"COMMAND", COMMAND }, + {"EMBED", EMBED }, + {"FRAME", FRAME }, + {"HR", HR }, + {"IMAGE", IMAGE }, + {"IMG", IMG }, + {"INPUT", INPUT }, + {"ISINDEX", ISINDEX }, + {"KEYGEN", KEYGEN }, + {"LINK", LINK }, + {"MENUITEM", MENUITEM }, + {"META", META }, + {"NEXTID", NEXTID }, + {"PARAM", PARAM }, + {"SOURCE", SOURCE }, + {"TRACK", TRACK }, + {"WBR", WBR }, + {"A", A }, + {"ABBR", ABBR }, + {"ADDRESS", ADDRESS }, + {"ARTICLE", ARTICLE }, + {"ASIDE", ASIDE }, + {"AUDIO", AUDIO }, + {"B", B }, + {"BDI", BDI }, + {"BDO", BDO }, + {"BLOCKQUOTE", BLOCKQUOTE}, + {"BODY", BODY }, + {"BUTTON", BUTTON }, + {"CANVAS", CANVAS }, + {"CAPTION", CAPTION }, + {"CITE", CITE }, + {"CODE", CODE }, + {"COLGROUP", COLGROUP }, + {"DATA", DATA }, + {"DATALIST", DATALIST }, + {"DD", DD }, + {"DEL", DEL }, + {"DETAILS", DETAILS }, + {"DFN", DFN }, + {"DIALOG", DIALOG }, + {"DIV", DIV }, + {"DL", DL }, + {"DT", DT }, + {"EM", EM }, + {"FIELDSET", FIELDSET }, + {"FIGCAPTION", FIGCAPTION}, + {"FIGURE", FIGURE }, + {"FOOTER", FOOTER }, + {"FORM", FORM }, + {"H1", H1 }, + {"H2", H2 }, + {"H3", H3 }, + {"H4", H4 }, + {"H5", H5 }, + {"H6", H6 }, + {"HEAD", HEAD }, + {"HEADER", HEADER }, + {"HGROUP", HGROUP }, + {"HTML", HTML }, + {"I", I }, + {"IFRAME", IFRAME }, + {"INS", INS }, + {"KBD", KBD }, + {"LABEL", LABEL }, + {"LEGEND", LEGEND }, + {"LI", LI }, + {"MAIN", MAIN }, + {"MAP", MAP }, + {"MARK", MARK }, + {"MATH", MATH }, + {"MENU", MENU }, + {"METER", METER }, + {"NAV", NAV }, + {"NOSCRIPT", NOSCRIPT }, + {"OBJECT", OBJECT }, + {"OL", OL }, + {"OPTGROUP", OPTGROUP }, + {"OPTION", OPTION }, + {"OUTPUT", OUTPUT }, + {"P", P }, + {"PICTURE", PICTURE }, + {"PRE", PRE }, + {"PROGRESS", PROGRESS }, + {"Q", Q }, + {"RB", RB }, + {"RP", RP }, + {"RT", RT }, + {"RTC", RTC }, + {"RUBY", RUBY }, + {"S", S }, + {"SAMP", SAMP }, + {"SCRIPT", SCRIPT }, + {"SECTION", SECTION }, + {"SELECT", SELECT }, + {"SLOT", SLOT }, + {"SMALL", SMALL }, + {"SPAN", SPAN }, + {"STRONG", STRONG }, + {"STYLE", STYLE }, + {"SUB", SUB }, + {"SUMMARY", SUMMARY }, + {"SUP", SUP }, + {"SVG", SVG }, + {"TABLE", TABLE }, + {"TBODY", TBODY }, + {"TD", TD }, + {"TEMPLATE", TEMPLATE }, + {"TEXTAREA", TEXTAREA }, + {"TFOOT", TFOOT }, + {"TH", TH }, + {"THEAD", THEAD }, + {"TIME", TIME }, + {"TITLE", TITLE }, + {"TR", TR }, + {"U", U }, + {"UL", UL }, + {"VAR", VAR }, + {"VIDEO", VIDEO }, + {"CUSTOM", CUSTOM }, +}; + +static const TagType TAG_TYPES_NOT_ALLOWED_IN_PARAGRAPHS[] = { + ADDRESS, ARTICLE, ASIDE, BLOCKQUOTE, DETAILS, DIV, DL, + FIELDSET, FIGCAPTION, FIGURE, FOOTER, FORM, H1, H2, + H3, H4, H5, H6, HEADER, HR, MAIN, + NAV, OL, P, PRE, SECTION, +}; + +static TagType tag_type_for_name(const String *tag_name) { + for (int i = 0; i < 126; i++) { + const TagMapEntry *entry = &TAG_TYPES_BY_TAG_NAME[i]; + if ( + strlen(entry->tag_name) == tag_name->size && + memcmp(tag_name->contents, entry->tag_name, tag_name->size) == 0 + ) { + return entry->tag_type; + } + } + return CUSTOM; +} + +static inline Tag tag_new() { + Tag tag; + tag.type = END_; + tag.custom_tag_name = (String) array_new(); + return tag; +} + +static inline Tag tag_for_name(String name) { + Tag tag = tag_new(); + tag.type = tag_type_for_name(&name); + if (tag.type == CUSTOM) { + tag.custom_tag_name = name; + } else { + array_delete(&name); + } + return tag; +} + +static inline void tag_free(Tag *tag) { + if (tag->type == CUSTOM) { + array_delete(&tag->custom_tag_name); + } +} + +static inline bool tag_is_void(const Tag *self) { + return self->type < END_OF_VOID_TAGS; +} + +static inline bool tag_eq(const Tag *self, const Tag *other) { + if (self->type != other->type) return false; + if (self->type == CUSTOM) { + if (self->custom_tag_name.size != other->custom_tag_name.size) { + return false; + } + if (memcmp( + self->custom_tag_name.contents, + other->custom_tag_name.contents, + self->custom_tag_name.size + ) != 0) { + return false; + } + } + return true; +} + +static bool tag_can_contain(Tag *self, const Tag *other) { + TagType child = other->type; + + switch (self->type) { + case LI: + return child != LI; + + case DT: + case DD: + return child != DT && child != DD; + + case P: + for (int i = 0; i < 26; i++) { + if (child == TAG_TYPES_NOT_ALLOWED_IN_PARAGRAPHS[i]) { + return false; + } + } + return true; + + case COLGROUP: + return child == COL; + + case RB: + case RT: + case RP: + return child != RB && child != RT && child != RP; + + case OPTGROUP: + return child != OPTGROUP; + + case TR: + return child != TR; + + case TD: + case TH: + return child != TD && child != TH && child != TR; + + default: + return true; + } +} -- cgit v1.2.3