├── .gitignore
├── Cargo.toml
├── binding.gyp
├── bindings
    ├── node
    │   ├── binding.cc
    │   └── index.js
    └── rust
    │   ├── build.rs
    │   └── lib.rs
├── grammar.js
├── package.json
├── src
    ├── grammar.json
    ├── node-types.json
    ├── parser.c
    ├── scanner.cc
    ├── tag.h
    └── tree_sitter
    │   └── parser.h
└── test
    └── corpus
        └── example.txt


/.gitignore:
--------------------------------------------------------------------------------
 1 | Cargo.lock
 2 | node_modules
 3 | .node-version
 4 | build
 5 | *.log
 6 | /test.js
 7 | /examples/npm
 8 | package-lock.json
 9 | /target/
10 | 


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "tree-sitter-rsx"
 3 | description = "rsx grammar for the tree-sitter parsing library"
 4 | version = "0.0.1"
 5 | keywords = ["incremental", "parsing", "rsx"]
 6 | categories = ["parsing", "text-editors"]
 7 | repository = "https://github.com/tree-sitter/tree-sitter-rsx"
 8 | edition = "2018"
 9 | license = "MIT"
10 | 
11 | build = "bindings/rust/build.rs"
12 | include = [
13 |   "bindings/rust/*",
14 |   "grammar.js",
15 |   "queries/*",
16 |   "src/*",
17 | ]
18 | 
19 | [lib]
20 | path = "bindings/rust/lib.rs"
21 | 
22 | [dependencies]
23 | tree-sitter = "~0.20"
24 | 
25 | [build-dependencies]
26 | cc = "1.0"
27 | 


--------------------------------------------------------------------------------
/binding.gyp:
--------------------------------------------------------------------------------
 1 | {
 2 |   "targets": [
 3 |     {
 4 |       "target_name": "tree_sitter_rsx_binding",
 5 |       "include_dirs": [
 6 |         "<!(node -e \"require('nan')\")",
 7 |         "src"
 8 |       ],
 9 |       "sources": [
10 |         "bindings/node/binding.cc",
11 |         "src/parser.c",
12 |         # If your language uses an external scanner, add it here.
13 |       ],
14 |       "cflags_c": [
15 |         "-std=c99",
16 |       ]
17 |     }
18 |   ]
19 | }
20 | 


--------------------------------------------------------------------------------
/bindings/node/binding.cc:
--------------------------------------------------------------------------------
 1 | #include "tree_sitter/parser.h"
 2 | #include <node.h>
 3 | #include "nan.h"
 4 | 
 5 | using namespace v8;
 6 | 
 7 | extern "C" TSLanguage * tree_sitter_rsx();
 8 | 
 9 | namespace {
10 | 
11 | NAN_METHOD(New) {}
12 | 
13 | void Init(Local<Object> exports, Local<Object> module) {
14 |   Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(New);
15 |   tpl->SetClassName(Nan::New("Language").ToLocalChecked());
16 |   tpl->InstanceTemplate()->SetInternalFieldCount(1);
17 | 
18 |   Local<Function> constructor = Nan::GetFunction(tpl).ToLocalChecked();
19 |   Local<Object> instance = constructor->NewInstance(Nan::GetCurrentContext()).ToLocalChecked();
20 |   Nan::SetInternalFieldPointer(instance, 0, tree_sitter_rsx());
21 | 
22 |   Nan::Set(instance, Nan::New("name").ToLocalChecked(), Nan::New("rsx").ToLocalChecked());
23 |   Nan::Set(module, Nan::New("exports").ToLocalChecked(), instance);
24 | }
25 | 
26 | NODE_MODULE(tree_sitter_rsx_binding, Init)
27 | 
28 | }  // namespace
29 | 


--------------------------------------------------------------------------------
/bindings/node/index.js:
--------------------------------------------------------------------------------
 1 | try {
 2 |   module.exports = require("../../build/Release/tree_sitter_rsx_binding");
 3 | } catch (error1) {
 4 |   if (error1.code !== 'MODULE_NOT_FOUND') {
 5 |     throw error1;
 6 |   }
 7 |   try {
 8 |     module.exports = require("../../build/Debug/tree_sitter_rsx_binding");
 9 |   } catch (error2) {
10 |     if (error2.code !== 'MODULE_NOT_FOUND') {
11 |       throw error2;
12 |     }
13 |     throw error1
14 |   }
15 | }
16 | 
17 | try {
18 |   module.exports.nodeTypeInfo = require("../../src/node-types.json");
19 | } catch (_) {}
20 | 


--------------------------------------------------------------------------------
/bindings/rust/build.rs:
--------------------------------------------------------------------------------
 1 | fn main() {
 2 |     let src_dir = std::path::Path::new("src");
 3 | 
 4 |     let mut c_config = cc::Build::new();
 5 |     c_config.include(&src_dir);
 6 |     c_config
 7 |         .flag_if_supported("-Wno-unused-parameter")
 8 |         .flag_if_supported("-Wno-unused-but-set-variable")
 9 |         .flag_if_supported("-Wno-trigraphs");
10 |     let parser_path = src_dir.join("parser.c");
11 |     c_config.file(&parser_path);
12 | 
13 |     // If your language uses an external scanner written in C,
14 |     // then include this block of code:
15 | 
16 |     /*
17 |     let scanner_path = src_dir.join("scanner.c");
18 |     c_config.file(&scanner_path);
19 |     println!("cargo:rerun-if-changed={}", scanner_path.to_str().unwrap());
20 |     */
21 | 
22 |     c_config.compile("parser");
23 |     println!("cargo:rerun-if-changed={}", parser_path.to_str().unwrap());
24 | 
25 |     // If your language uses an external scanner written in C++,
26 |     // then include this block of code:
27 | 
28 |     let mut cpp_config = cc::Build::new();
29 |     cpp_config.cpp(true);
30 |     cpp_config.include(&src_dir);
31 |     cpp_config
32 |         .flag_if_supported("-Wno-unused-parameter")
33 |         .flag_if_supported("-Wno-unused-but-set-variable");
34 |     let scanner_path = src_dir.join("scanner.cc");
35 |     cpp_config.file(&scanner_path);
36 |     cpp_config.compile("scanner");
37 |     println!("cargo:rerun-if-changed={}", scanner_path.to_str().unwrap());
38 | }
39 | 


--------------------------------------------------------------------------------
/bindings/rust/lib.rs:
--------------------------------------------------------------------------------
 1 | //! This crate provides rsx language support for the [tree-sitter][] parsing library.
 2 | //!
 3 | //! Typically, you will use the [language][language func] function to add this language to a
 4 | //! tree-sitter [Parser][], and then use the parser to parse some code:
 5 | //!
 6 | //! ```
 7 | //! let code = "";
 8 | //! let mut parser = tree_sitter::Parser::new();
 9 | //! parser.set_language(tree_sitter_rsx::language()).expect("Error loading rsx grammar");
10 | //! let tree = parser.parse(code, None).unwrap();
11 | //! ```
12 | //!
13 | //! [Language]: https://docs.rs/tree-sitter/*/tree_sitter/struct.Language.html
14 | //! [language func]: fn.language.html
15 | //! [Parser]: https://docs.rs/tree-sitter/*/tree_sitter/struct.Parser.html
16 | //! [tree-sitter]: https://tree-sitter.github.io/
17 | 
18 | use tree_sitter::Language;
19 | 
20 | extern "C" {
21 |     fn tree_sitter_rsx() -> Language;
22 | }
23 | 
24 | /// Get the tree-sitter [Language][] for this grammar.
25 | ///
26 | /// [Language]: https://docs.rs/tree-sitter/*/tree_sitter/struct.Language.html
27 | pub fn language() -> Language {
28 |     unsafe { tree_sitter_rsx() }
29 | }
30 | 
31 | /// The content of the [`node-types.json`][] file for this grammar.
32 | ///
33 | /// [`node-types.json`]: https://tree-sitter.github.io/tree-sitter/using-parsers#static-node-types
34 | pub const NODE_TYPES: &'static str = include_str!("../../src/node-types.json");
35 | 
36 | // Uncomment these to include any queries that this grammar contains
37 | 
38 | // pub const HIGHLIGHTS_QUERY: &'static str = include_str!("../../queries/highlights.scm");
39 | // pub const INJECTIONS_QUERY: &'static str = include_str!("../../queries/injections.scm");
40 | // pub const LOCALS_QUERY: &'static str = include_str!("../../queries/locals.scm");
41 | // pub const TAGS_QUERY: &'static str = include_str!("../../queries/tags.scm");
42 | 
43 | #[cfg(test)]
44 | mod tests {
45 |     #[test]
46 |     fn test_can_load_grammar() {
47 |         let mut parser = tree_sitter::Parser::new();
48 |         parser
49 |             .set_language(super::language())
50 |             .expect("Error loading rsx language");
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/grammar.js:
--------------------------------------------------------------------------------
  1 | module.exports = grammar({
  2 |     name: "rsx",
  3 |     extras: ($) => [$.comment, /\s+/],
  4 | 
  5 |     externals: ($) => [
  6 |         $._start_tag_name,
  7 |         $._script_start_tag_name,
  8 |         $._style_start_tag_name,
  9 |         $._end_tag_name,
 10 |         $.erroneous_end_tag_name,
 11 |         "/>",
 12 |         $._implicit_end_tag,
 13 |         $.raw_text,
 14 |         $.comment,
 15 |     ],
 16 | 
 17 |     rules: {
 18 |         fragment: ($) => repeat($._node),
 19 | 
 20 |         _node: ($) =>
 21 |             choice(
 22 |                 $.rust_text,
 23 |                 $.element,
 24 |                 $.script_element,
 25 |                 $.style_element,
 26 |                 $.erroneous_end_tag
 27 |             ),
 28 | 
 29 |         element: ($) =>
 30 |             choice(
 31 |                 seq(
 32 |                     $.start_tag,
 33 |                     repeat($._node),
 34 |                     choice($.end_tag, $._implicit_end_tag)
 35 |                 ),
 36 |                 $.self_closing_tag
 37 |             ),
 38 | 
 39 |         script_element: ($) =>
 40 |             seq(
 41 |                 alias($.script_start_tag, $.start_tag),
 42 |                 optional($.raw_text),
 43 |                 $.end_tag
 44 |             ),
 45 | 
 46 |         style_element: ($) =>
 47 |             seq(
 48 |                 alias($.style_start_tag, $.start_tag),
 49 |                 optional($.raw_text),
 50 |                 $.end_tag
 51 |             ),
 52 | 
 53 |         start_tag: ($) =>
 54 |             seq(
 55 |                 "<",
 56 |                 alias($._start_tag_name, $.tag_name),
 57 |                 repeat($.attribute),
 58 |                 ">"
 59 |             ),
 60 | 
 61 |         script_start_tag: ($) =>
 62 |             seq(
 63 |                 "<",
 64 |                 alias($._script_start_tag_name, $.tag_name),
 65 |                 repeat($.attribute),
 66 |                 ">"
 67 |             ),
 68 | 
 69 |         style_start_tag: ($) =>
 70 |             seq(
 71 |                 "<",
 72 |                 alias($._style_start_tag_name, $.tag_name),
 73 |                 repeat($.attribute),
 74 |                 ">"
 75 |             ),
 76 | 
 77 |         self_closing_tag: ($) =>
 78 |             seq(
 79 |                 "<",
 80 |                 alias($._start_tag_name, $.tag_name),
 81 |                 repeat($.attribute),
 82 |                 "/>"
 83 |             ),
 84 | 
 85 |         end_tag: ($) => seq("</", alias($._end_tag_name, $.tag_name), ">"),
 86 | 
 87 |         erroneous_end_tag: ($) => seq("</", $.erroneous_end_tag_name, ">"),
 88 | 
 89 |         attribute: ($) =>
 90 |             seq(
 91 |                 $.attribute_name,
 92 |                 optional(
 93 |                     seq(
 94 |                         "=",
 95 |                         choice(
 96 |                             $.attribute_value,
 97 |                             $.quoted_attribute_value,
 98 |                             $.rust_attribute
 99 |                         )
100 |                     )
101 |                 )
102 |             ),
103 | 
104 |         attribute_name: ($) => /[^<>"'/=\s]+/,
105 | 
106 |         attribute_value: ($) => /[^<>"'=\s]+/,
107 | 
108 |         rust_attribute: ($) => seq("{", /[^}]*/, "}"),
109 | 
110 |         quoted_attribute_value: ($) =>
111 |             choice(
112 |                 seq("'", optional(alias(/[^']+/, $.attribute_value)), "'"),
113 |                 seq('"', optional(alias(/[^"]+/, $.attribute_value)), '"')
114 |             ),
115 | 
116 |         rust_text: ($) => /[^<>\s]([^<>]*[^<>\s])?/,
117 |     },
118 | });
119 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "tree-sitter-rsx",
 3 |   "version": "0.0.1",
 4 |   "description": "rsx grammar for tree-sitter",
 5 |   "main": "bindings/node",
 6 |   "keywords": [
 7 |     "parsing",
 8 |     "incremental"
 9 |   ],
10 |   "dependencies": {
11 |     "nan": "^2.12.1"
12 |   },
13 |   "devDependencies": {
14 |     "tree-sitter-cli": "^0.20.6"
15 |   },
16 |   "scripts": {
17 |     "test": "tree-sitter test"
18 |   }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/grammar.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "name": "rsx",
  3 |   "rules": {
  4 |     "fragment": {
  5 |       "type": "REPEAT",
  6 |       "content": {
  7 |         "type": "SYMBOL",
  8 |         "name": "_node"
  9 |       }
 10 |     },
 11 |     "_node": {
 12 |       "type": "CHOICE",
 13 |       "members": [
 14 |         {
 15 |           "type": "SYMBOL",
 16 |           "name": "rust_text"
 17 |         },
 18 |         {
 19 |           "type": "SYMBOL",
 20 |           "name": "element"
 21 |         },
 22 |         {
 23 |           "type": "SYMBOL",
 24 |           "name": "script_element"
 25 |         },
 26 |         {
 27 |           "type": "SYMBOL",
 28 |           "name": "style_element"
 29 |         },
 30 |         {
 31 |           "type": "SYMBOL",
 32 |           "name": "erroneous_end_tag"
 33 |         }
 34 |       ]
 35 |     },
 36 |     "element": {
 37 |       "type": "CHOICE",
 38 |       "members": [
 39 |         {
 40 |           "type": "SEQ",
 41 |           "members": [
 42 |             {
 43 |               "type": "SYMBOL",
 44 |               "name": "start_tag"
 45 |             },
 46 |             {
 47 |               "type": "REPEAT",
 48 |               "content": {
 49 |                 "type": "SYMBOL",
 50 |                 "name": "_node"
 51 |               }
 52 |             },
 53 |             {
 54 |               "type": "CHOICE",
 55 |               "members": [
 56 |                 {
 57 |                   "type": "SYMBOL",
 58 |                   "name": "end_tag"
 59 |                 },
 60 |                 {
 61 |                   "type": "SYMBOL",
 62 |                   "name": "_implicit_end_tag"
 63 |                 }
 64 |               ]
 65 |             }
 66 |           ]
 67 |         },
 68 |         {
 69 |           "type": "SYMBOL",
 70 |           "name": "self_closing_tag"
 71 |         }
 72 |       ]
 73 |     },
 74 |     "script_element": {
 75 |       "type": "SEQ",
 76 |       "members": [
 77 |         {
 78 |           "type": "ALIAS",
 79 |           "content": {
 80 |             "type": "SYMBOL",
 81 |             "name": "script_start_tag"
 82 |           },
 83 |           "named": true,
 84 |           "value": "start_tag"
 85 |         },
 86 |         {
 87 |           "type": "CHOICE",
 88 |           "members": [
 89 |             {
 90 |               "type": "SYMBOL",
 91 |               "name": "raw_text"
 92 |             },
 93 |             {
 94 |               "type": "BLANK"
 95 |             }
 96 |           ]
 97 |         },
 98 |         {
 99 |           "type": "SYMBOL",
100 |           "name": "end_tag"
101 |         }
102 |       ]
103 |     },
104 |     "style_element": {
105 |       "type": "SEQ",
106 |       "members": [
107 |         {
108 |           "type": "ALIAS",
109 |           "content": {
110 |             "type": "SYMBOL",
111 |             "name": "style_start_tag"
112 |           },
113 |           "named": true,
114 |           "value": "start_tag"
115 |         },
116 |         {
117 |           "type": "CHOICE",
118 |           "members": [
119 |             {
120 |               "type": "SYMBOL",
121 |               "name": "raw_text"
122 |             },
123 |             {
124 |               "type": "BLANK"
125 |             }
126 |           ]
127 |         },
128 |         {
129 |           "type": "SYMBOL",
130 |           "name": "end_tag"
131 |         }
132 |       ]
133 |     },
134 |     "start_tag": {
135 |       "type": "SEQ",
136 |       "members": [
137 |         {
138 |           "type": "STRING",
139 |           "value": "<"
140 |         },
141 |         {
142 |           "type": "ALIAS",
143 |           "content": {
144 |             "type": "SYMBOL",
145 |             "name": "_start_tag_name"
146 |           },
147 |           "named": true,
148 |           "value": "tag_name"
149 |         },
150 |         {
151 |           "type": "REPEAT",
152 |           "content": {
153 |             "type": "SYMBOL",
154 |             "name": "attribute"
155 |           }
156 |         },
157 |         {
158 |           "type": "STRING",
159 |           "value": ">"
160 |         }
161 |       ]
162 |     },
163 |     "script_start_tag": {
164 |       "type": "SEQ",
165 |       "members": [
166 |         {
167 |           "type": "STRING",
168 |           "value": "<"
169 |         },
170 |         {
171 |           "type": "ALIAS",
172 |           "content": {
173 |             "type": "SYMBOL",
174 |             "name": "_script_start_tag_name"
175 |           },
176 |           "named": true,
177 |           "value": "tag_name"
178 |         },
179 |         {
180 |           "type": "REPEAT",
181 |           "content": {
182 |             "type": "SYMBOL",
183 |             "name": "attribute"
184 |           }
185 |         },
186 |         {
187 |           "type": "STRING",
188 |           "value": ">"
189 |         }
190 |       ]
191 |     },
192 |     "style_start_tag": {
193 |       "type": "SEQ",
194 |       "members": [
195 |         {
196 |           "type": "STRING",
197 |           "value": "<"
198 |         },
199 |         {
200 |           "type": "ALIAS",
201 |           "content": {
202 |             "type": "SYMBOL",
203 |             "name": "_style_start_tag_name"
204 |           },
205 |           "named": true,
206 |           "value": "tag_name"
207 |         },
208 |         {
209 |           "type": "REPEAT",
210 |           "content": {
211 |             "type": "SYMBOL",
212 |             "name": "attribute"
213 |           }
214 |         },
215 |         {
216 |           "type": "STRING",
217 |           "value": ">"
218 |         }
219 |       ]
220 |     },
221 |     "self_closing_tag": {
222 |       "type": "SEQ",
223 |       "members": [
224 |         {
225 |           "type": "STRING",
226 |           "value": "<"
227 |         },
228 |         {
229 |           "type": "ALIAS",
230 |           "content": {
231 |             "type": "SYMBOL",
232 |             "name": "_start_tag_name"
233 |           },
234 |           "named": true,
235 |           "value": "tag_name"
236 |         },
237 |         {
238 |           "type": "REPEAT",
239 |           "content": {
240 |             "type": "SYMBOL",
241 |             "name": "attribute"
242 |           }
243 |         },
244 |         {
245 |           "type": "STRING",
246 |           "value": "/>"
247 |         }
248 |       ]
249 |     },
250 |     "end_tag": {
251 |       "type": "SEQ",
252 |       "members": [
253 |         {
254 |           "type": "STRING",
255 |           "value": "</"
256 |         },
257 |         {
258 |           "type": "ALIAS",
259 |           "content": {
260 |             "type": "SYMBOL",
261 |             "name": "_end_tag_name"
262 |           },
263 |           "named": true,
264 |           "value": "tag_name"
265 |         },
266 |         {
267 |           "type": "STRING",
268 |           "value": ">"
269 |         }
270 |       ]
271 |     },
272 |     "erroneous_end_tag": {
273 |       "type": "SEQ",
274 |       "members": [
275 |         {
276 |           "type": "STRING",
277 |           "value": "</"
278 |         },
279 |         {
280 |           "type": "SYMBOL",
281 |           "name": "erroneous_end_tag_name"
282 |         },
283 |         {
284 |           "type": "STRING",
285 |           "value": ">"
286 |         }
287 |       ]
288 |     },
289 |     "attribute": {
290 |       "type": "SEQ",
291 |       "members": [
292 |         {
293 |           "type": "SYMBOL",
294 |           "name": "attribute_name"
295 |         },
296 |         {
297 |           "type": "CHOICE",
298 |           "members": [
299 |             {
300 |               "type": "SEQ",
301 |               "members": [
302 |                 {
303 |                   "type": "STRING",
304 |                   "value": "="
305 |                 },
306 |                 {
307 |                   "type": "CHOICE",
308 |                   "members": [
309 |                     {
310 |                       "type": "SYMBOL",
311 |                       "name": "attribute_value"
312 |                     },
313 |                     {
314 |                       "type": "SYMBOL",
315 |                       "name": "quoted_attribute_value"
316 |                     },
317 |                     {
318 |                       "type": "SYMBOL",
319 |                       "name": "rust_attribute"
320 |                     }
321 |                   ]
322 |                 }
323 |               ]
324 |             },
325 |             {
326 |               "type": "BLANK"
327 |             }
328 |           ]
329 |         }
330 |       ]
331 |     },
332 |     "attribute_name": {
333 |       "type": "PATTERN",
334 |       "value": "[^<>\"'/=\\s]+"
335 |     },
336 |     "attribute_value": {
337 |       "type": "PATTERN",
338 |       "value": "[^<>\"'=\\s]+"
339 |     },
340 |     "rust_attribute": {
341 |       "type": "SEQ",
342 |       "members": [
343 |         {
344 |           "type": "STRING",
345 |           "value": "{"
346 |         },
347 |         {
348 |           "type": "PATTERN",
349 |           "value": "[^}]*"
350 |         },
351 |         {
352 |           "type": "STRING",
353 |           "value": "}"
354 |         }
355 |       ]
356 |     },
357 |     "quoted_attribute_value": {
358 |       "type": "CHOICE",
359 |       "members": [
360 |         {
361 |           "type": "SEQ",
362 |           "members": [
363 |             {
364 |               "type": "STRING",
365 |               "value": "'"
366 |             },
367 |             {
368 |               "type": "CHOICE",
369 |               "members": [
370 |                 {
371 |                   "type": "ALIAS",
372 |                   "content": {
373 |                     "type": "PATTERN",
374 |                     "value": "[^']+"
375 |                   },
376 |                   "named": true,
377 |                   "value": "attribute_value"
378 |                 },
379 |                 {
380 |                   "type": "BLANK"
381 |                 }
382 |               ]
383 |             },
384 |             {
385 |               "type": "STRING",
386 |               "value": "'"
387 |             }
388 |           ]
389 |         },
390 |         {
391 |           "type": "SEQ",
392 |           "members": [
393 |             {
394 |               "type": "STRING",
395 |               "value": "\""
396 |             },
397 |             {
398 |               "type": "CHOICE",
399 |               "members": [
400 |                 {
401 |                   "type": "ALIAS",
402 |                   "content": {
403 |                     "type": "PATTERN",
404 |                     "value": "[^\"]+"
405 |                   },
406 |                   "named": true,
407 |                   "value": "attribute_value"
408 |                 },
409 |                 {
410 |                   "type": "BLANK"
411 |                 }
412 |               ]
413 |             },
414 |             {
415 |               "type": "STRING",
416 |               "value": "\""
417 |             }
418 |           ]
419 |         }
420 |       ]
421 |     },
422 |     "rust_text": {
423 |       "type": "PATTERN",
424 |       "value": "[^<>\\s]([^<>]*[^<>\\s])?"
425 |     }
426 |   },
427 |   "extras": [
428 |     {
429 |       "type": "SYMBOL",
430 |       "name": "comment"
431 |     },
432 |     {
433 |       "type": "PATTERN",
434 |       "value": "\\s+"
435 |     }
436 |   ],
437 |   "conflicts": [],
438 |   "precedences": [],
439 |   "externals": [
440 |     {
441 |       "type": "SYMBOL",
442 |       "name": "_start_tag_name"
443 |     },
444 |     {
445 |       "type": "SYMBOL",
446 |       "name": "_script_start_tag_name"
447 |     },
448 |     {
449 |       "type": "SYMBOL",
450 |       "name": "_style_start_tag_name"
451 |     },
452 |     {
453 |       "type": "SYMBOL",
454 |       "name": "_end_tag_name"
455 |     },
456 |     {
457 |       "type": "SYMBOL",
458 |       "name": "erroneous_end_tag_name"
459 |     },
460 |     {
461 |       "type": "STRING",
462 |       "value": "/>"
463 |     },
464 |     {
465 |       "type": "SYMBOL",
466 |       "name": "_implicit_end_tag"
467 |     },
468 |     {
469 |       "type": "SYMBOL",
470 |       "name": "raw_text"
471 |     },
472 |     {
473 |       "type": "SYMBOL",
474 |       "name": "comment"
475 |     }
476 |   ],
477 |   "inline": [],
478 |   "supertypes": []
479 | }
480 | 
481 | 


--------------------------------------------------------------------------------
/src/node-types.json:
--------------------------------------------------------------------------------
  1 | [
  2 |   {
  3 |     "type": "attribute",
  4 |     "named": true,
  5 |     "fields": {},
  6 |     "children": {
  7 |       "multiple": true,
  8 |       "required": true,
  9 |       "types": [
 10 |         {
 11 |           "type": "attribute_name",
 12 |           "named": true
 13 |         },
 14 |         {
 15 |           "type": "attribute_value",
 16 |           "named": true
 17 |         },
 18 |         {
 19 |           "type": "quoted_attribute_value",
 20 |           "named": true
 21 |         },
 22 |         {
 23 |           "type": "rust_attribute",
 24 |           "named": true
 25 |         }
 26 |       ]
 27 |     }
 28 |   },
 29 |   {
 30 |     "type": "element",
 31 |     "named": true,
 32 |     "fields": {},
 33 |     "children": {
 34 |       "multiple": true,
 35 |       "required": true,
 36 |       "types": [
 37 |         {
 38 |           "type": "element",
 39 |           "named": true
 40 |         },
 41 |         {
 42 |           "type": "end_tag",
 43 |           "named": true
 44 |         },
 45 |         {
 46 |           "type": "erroneous_end_tag",
 47 |           "named": true
 48 |         },
 49 |         {
 50 |           "type": "rust_text",
 51 |           "named": true
 52 |         },
 53 |         {
 54 |           "type": "script_element",
 55 |           "named": true
 56 |         },
 57 |         {
 58 |           "type": "self_closing_tag",
 59 |           "named": true
 60 |         },
 61 |         {
 62 |           "type": "start_tag",
 63 |           "named": true
 64 |         },
 65 |         {
 66 |           "type": "style_element",
 67 |           "named": true
 68 |         }
 69 |       ]
 70 |     }
 71 |   },
 72 |   {
 73 |     "type": "end_tag",
 74 |     "named": true,
 75 |     "fields": {},
 76 |     "children": {
 77 |       "multiple": false,
 78 |       "required": true,
 79 |       "types": [
 80 |         {
 81 |           "type": "tag_name",
 82 |           "named": true
 83 |         }
 84 |       ]
 85 |     }
 86 |   },
 87 |   {
 88 |     "type": "erroneous_end_tag",
 89 |     "named": true,
 90 |     "fields": {},
 91 |     "children": {
 92 |       "multiple": false,
 93 |       "required": true,
 94 |       "types": [
 95 |         {
 96 |           "type": "erroneous_end_tag_name",
 97 |           "named": true
 98 |         }
 99 |       ]
100 |     }
101 |   },
102 |   {
103 |     "type": "fragment",
104 |     "named": true,
105 |     "fields": {},
106 |     "children": {
107 |       "multiple": true,
108 |       "required": false,
109 |       "types": [
110 |         {
111 |           "type": "element",
112 |           "named": true
113 |         },
114 |         {
115 |           "type": "erroneous_end_tag",
116 |           "named": true
117 |         },
118 |         {
119 |           "type": "rust_text",
120 |           "named": true
121 |         },
122 |         {
123 |           "type": "script_element",
124 |           "named": true
125 |         },
126 |         {
127 |           "type": "style_element",
128 |           "named": true
129 |         }
130 |       ]
131 |     }
132 |   },
133 |   {
134 |     "type": "quoted_attribute_value",
135 |     "named": true,
136 |     "fields": {},
137 |     "children": {
138 |       "multiple": false,
139 |       "required": false,
140 |       "types": [
141 |         {
142 |           "type": "attribute_value",
143 |           "named": true
144 |         }
145 |       ]
146 |     }
147 |   },
148 |   {
149 |     "type": "rust_attribute",
150 |     "named": true,
151 |     "fields": {}
152 |   },
153 |   {
154 |     "type": "script_element",
155 |     "named": true,
156 |     "fields": {},
157 |     "children": {
158 |       "multiple": true,
159 |       "required": true,
160 |       "types": [
161 |         {
162 |           "type": "end_tag",
163 |           "named": true
164 |         },
165 |         {
166 |           "type": "raw_text",
167 |           "named": true
168 |         },
169 |         {
170 |           "type": "start_tag",
171 |           "named": true
172 |         }
173 |       ]
174 |     }
175 |   },
176 |   {
177 |     "type": "self_closing_tag",
178 |     "named": true,
179 |     "fields": {},
180 |     "children": {
181 |       "multiple": true,
182 |       "required": true,
183 |       "types": [
184 |         {
185 |           "type": "attribute",
186 |           "named": true
187 |         },
188 |         {
189 |           "type": "tag_name",
190 |           "named": true
191 |         }
192 |       ]
193 |     }
194 |   },
195 |   {
196 |     "type": "start_tag",
197 |     "named": true,
198 |     "fields": {},
199 |     "children": {
200 |       "multiple": true,
201 |       "required": true,
202 |       "types": [
203 |         {
204 |           "type": "attribute",
205 |           "named": true
206 |         },
207 |         {
208 |           "type": "tag_name",
209 |           "named": true
210 |         }
211 |       ]
212 |     }
213 |   },
214 |   {
215 |     "type": "style_element",
216 |     "named": true,
217 |     "fields": {},
218 |     "children": {
219 |       "multiple": true,
220 |       "required": true,
221 |       "types": [
222 |         {
223 |           "type": "end_tag",
224 |           "named": true
225 |         },
226 |         {
227 |           "type": "raw_text",
228 |           "named": true
229 |         },
230 |         {
231 |           "type": "start_tag",
232 |           "named": true
233 |         }
234 |       ]
235 |     }
236 |   },
237 |   {
238 |     "type": "\"",
239 |     "named": false
240 |   },
241 |   {
242 |     "type": "'",
243 |     "named": false
244 |   },
245 |   {
246 |     "type": "/>",
247 |     "named": false
248 |   },
249 |   {
250 |     "type": "<",
251 |     "named": false
252 |   },
253 |   {
254 |     "type": "</",
255 |     "named": false
256 |   },
257 |   {
258 |     "type": "=",
259 |     "named": false
260 |   },
261 |   {
262 |     "type": ">",
263 |     "named": false
264 |   },
265 |   {
266 |     "type": "attribute_name",
267 |     "named": true
268 |   },
269 |   {
270 |     "type": "attribute_value",
271 |     "named": true
272 |   },
273 |   {
274 |     "type": "comment",
275 |     "named": true
276 |   },
277 |   {
278 |     "type": "erroneous_end_tag_name",
279 |     "named": true
280 |   },
281 |   {
282 |     "type": "raw_text",
283 |     "named": true
284 |   },
285 |   {
286 |     "type": "rust_text",
287 |     "named": true
288 |   },
289 |   {
290 |     "type": "tag_name",
291 |     "named": true
292 |   },
293 |   {
294 |     "type": "{",
295 |     "named": false
296 |   },
297 |   {
298 |     "type": "}",
299 |     "named": false
300 |   }
301 | ]


--------------------------------------------------------------------------------
/src/parser.c:
--------------------------------------------------------------------------------
   1 | #include <tree_sitter/parser.h>
   2 | 
   3 | #if defined(__GNUC__) || defined(__clang__)
   4 | #pragma GCC diagnostic push
   5 | #pragma GCC diagnostic ignored "-Wmissing-field-initializers"
   6 | #endif
   7 | 
   8 | #define LANGUAGE_VERSION 13
   9 | #define STATE_COUNT 92
  10 | #define LARGE_STATE_COUNT 2
  11 | #define SYMBOL_COUNT 40
  12 | #define ALIAS_COUNT 0
  13 | #define TOKEN_COUNT 24
  14 | #define EXTERNAL_TOKEN_COUNT 9
  15 | #define FIELD_COUNT 0
  16 | #define MAX_ALIAS_SEQUENCE_LENGTH 4
  17 | #define PRODUCTION_ID_COUNT 1
  18 | 
  19 | enum {
  20 |   anon_sym_LT = 1,
  21 |   anon_sym_GT = 2,
  22 |   anon_sym_SLASH_GT = 3,
  23 |   anon_sym_LT_SLASH = 4,
  24 |   anon_sym_EQ = 5,
  25 |   sym_attribute_name = 6,
  26 |   sym_attribute_value = 7,
  27 |   anon_sym_LBRACE = 8,
  28 |   aux_sym_rust_attribute_token1 = 9,
  29 |   anon_sym_RBRACE = 10,
  30 |   anon_sym_SQUOTE = 11,
  31 |   aux_sym_quoted_attribute_value_token1 = 12,
  32 |   anon_sym_DQUOTE = 13,
  33 |   aux_sym_quoted_attribute_value_token2 = 14,
  34 |   sym_rust_text = 15,
  35 |   sym__start_tag_name = 16,
  36 |   sym__script_start_tag_name = 17,
  37 |   sym__style_start_tag_name = 18,
  38 |   sym__end_tag_name = 19,
  39 |   sym_erroneous_end_tag_name = 20,
  40 |   sym__implicit_end_tag = 21,
  41 |   sym_raw_text = 22,
  42 |   sym_comment = 23,
  43 |   sym_fragment = 24,
  44 |   sym__node = 25,
  45 |   sym_element = 26,
  46 |   sym_script_element = 27,
  47 |   sym_style_element = 28,
  48 |   sym_start_tag = 29,
  49 |   sym_script_start_tag = 30,
  50 |   sym_style_start_tag = 31,
  51 |   sym_self_closing_tag = 32,
  52 |   sym_end_tag = 33,
  53 |   sym_erroneous_end_tag = 34,
  54 |   sym_attribute = 35,
  55 |   sym_rust_attribute = 36,
  56 |   sym_quoted_attribute_value = 37,
  57 |   aux_sym_fragment_repeat1 = 38,
  58 |   aux_sym_start_tag_repeat1 = 39,
  59 | };
  60 | 
  61 | static const char * const ts_symbol_names[] = {
  62 |   [ts_builtin_sym_end] = "end",
  63 |   [anon_sym_LT] = "<",
  64 |   [anon_sym_GT] = ">",
  65 |   [anon_sym_SLASH_GT] = "/>",
  66 |   [anon_sym_LT_SLASH] = "</",
  67 |   [anon_sym_EQ] = "=",
  68 |   [sym_attribute_name] = "attribute_name",
  69 |   [sym_attribute_value] = "attribute_value",
  70 |   [anon_sym_LBRACE] = "{",
  71 |   [aux_sym_rust_attribute_token1] = "rust_attribute_token1",
  72 |   [anon_sym_RBRACE] = "}",
  73 |   [anon_sym_SQUOTE] = "'",
  74 |   [aux_sym_quoted_attribute_value_token1] = "attribute_value",
  75 |   [anon_sym_DQUOTE] = "\"",
  76 |   [aux_sym_quoted_attribute_value_token2] = "attribute_value",
  77 |   [sym_rust_text] = "rust_text",
  78 |   [sym__start_tag_name] = "tag_name",
  79 |   [sym__script_start_tag_name] = "tag_name",
  80 |   [sym__style_start_tag_name] = "tag_name",
  81 |   [sym__end_tag_name] = "tag_name",
  82 |   [sym_erroneous_end_tag_name] = "erroneous_end_tag_name",
  83 |   [sym__implicit_end_tag] = "_implicit_end_tag",
  84 |   [sym_raw_text] = "raw_text",
  85 |   [sym_comment] = "comment",
  86 |   [sym_fragment] = "fragment",
  87 |   [sym__node] = "_node",
  88 |   [sym_element] = "element",
  89 |   [sym_script_element] = "script_element",
  90 |   [sym_style_element] = "style_element",
  91 |   [sym_start_tag] = "start_tag",
  92 |   [sym_script_start_tag] = "start_tag",
  93 |   [sym_style_start_tag] = "start_tag",
  94 |   [sym_self_closing_tag] = "self_closing_tag",
  95 |   [sym_end_tag] = "end_tag",
  96 |   [sym_erroneous_end_tag] = "erroneous_end_tag",
  97 |   [sym_attribute] = "attribute",
  98 |   [sym_rust_attribute] = "rust_attribute",
  99 |   [sym_quoted_attribute_value] = "quoted_attribute_value",
 100 |   [aux_sym_fragment_repeat1] = "fragment_repeat1",
 101 |   [aux_sym_start_tag_repeat1] = "start_tag_repeat1",
 102 | };
 103 | 
 104 | static const TSSymbol ts_symbol_map[] = {
 105 |   [ts_builtin_sym_end] = ts_builtin_sym_end,
 106 |   [anon_sym_LT] = anon_sym_LT,
 107 |   [anon_sym_GT] = anon_sym_GT,
 108 |   [anon_sym_SLASH_GT] = anon_sym_SLASH_GT,
 109 |   [anon_sym_LT_SLASH] = anon_sym_LT_SLASH,
 110 |   [anon_sym_EQ] = anon_sym_EQ,
 111 |   [sym_attribute_name] = sym_attribute_name,
 112 |   [sym_attribute_value] = sym_attribute_value,
 113 |   [anon_sym_LBRACE] = anon_sym_LBRACE,
 114 |   [aux_sym_rust_attribute_token1] = aux_sym_rust_attribute_token1,
 115 |   [anon_sym_RBRACE] = anon_sym_RBRACE,
 116 |   [anon_sym_SQUOTE] = anon_sym_SQUOTE,
 117 |   [aux_sym_quoted_attribute_value_token1] = sym_attribute_value,
 118 |   [anon_sym_DQUOTE] = anon_sym_DQUOTE,
 119 |   [aux_sym_quoted_attribute_value_token2] = sym_attribute_value,
 120 |   [sym_rust_text] = sym_rust_text,
 121 |   [sym__start_tag_name] = sym__start_tag_name,
 122 |   [sym__script_start_tag_name] = sym__start_tag_name,
 123 |   [sym__style_start_tag_name] = sym__start_tag_name,
 124 |   [sym__end_tag_name] = sym__start_tag_name,
 125 |   [sym_erroneous_end_tag_name] = sym_erroneous_end_tag_name,
 126 |   [sym__implicit_end_tag] = sym__implicit_end_tag,
 127 |   [sym_raw_text] = sym_raw_text,
 128 |   [sym_comment] = sym_comment,
 129 |   [sym_fragment] = sym_fragment,
 130 |   [sym__node] = sym__node,
 131 |   [sym_element] = sym_element,
 132 |   [sym_script_element] = sym_script_element,
 133 |   [sym_style_element] = sym_style_element,
 134 |   [sym_start_tag] = sym_start_tag,
 135 |   [sym_script_start_tag] = sym_start_tag,
 136 |   [sym_style_start_tag] = sym_start_tag,
 137 |   [sym_self_closing_tag] = sym_self_closing_tag,
 138 |   [sym_end_tag] = sym_end_tag,
 139 |   [sym_erroneous_end_tag] = sym_erroneous_end_tag,
 140 |   [sym_attribute] = sym_attribute,
 141 |   [sym_rust_attribute] = sym_rust_attribute,
 142 |   [sym_quoted_attribute_value] = sym_quoted_attribute_value,
 143 |   [aux_sym_fragment_repeat1] = aux_sym_fragment_repeat1,
 144 |   [aux_sym_start_tag_repeat1] = aux_sym_start_tag_repeat1,
 145 | };
 146 | 
 147 | static const TSSymbolMetadata ts_symbol_metadata[] = {
 148 |   [ts_builtin_sym_end] = {
 149 |     .visible = false,
 150 |     .named = true,
 151 |   },
 152 |   [anon_sym_LT] = {
 153 |     .visible = true,
 154 |     .named = false,
 155 |   },
 156 |   [anon_sym_GT] = {
 157 |     .visible = true,
 158 |     .named = false,
 159 |   },
 160 |   [anon_sym_SLASH_GT] = {
 161 |     .visible = true,
 162 |     .named = false,
 163 |   },
 164 |   [anon_sym_LT_SLASH] = {
 165 |     .visible = true,
 166 |     .named = false,
 167 |   },
 168 |   [anon_sym_EQ] = {
 169 |     .visible = true,
 170 |     .named = false,
 171 |   },
 172 |   [sym_attribute_name] = {
 173 |     .visible = true,
 174 |     .named = true,
 175 |   },
 176 |   [sym_attribute_value] = {
 177 |     .visible = true,
 178 |     .named = true,
 179 |   },
 180 |   [anon_sym_LBRACE] = {
 181 |     .visible = true,
 182 |     .named = false,
 183 |   },
 184 |   [aux_sym_rust_attribute_token1] = {
 185 |     .visible = false,
 186 |     .named = false,
 187 |   },
 188 |   [anon_sym_RBRACE] = {
 189 |     .visible = true,
 190 |     .named = false,
 191 |   },
 192 |   [anon_sym_SQUOTE] = {
 193 |     .visible = true,
 194 |     .named = false,
 195 |   },
 196 |   [aux_sym_quoted_attribute_value_token1] = {
 197 |     .visible = true,
 198 |     .named = true,
 199 |   },
 200 |   [anon_sym_DQUOTE] = {
 201 |     .visible = true,
 202 |     .named = false,
 203 |   },
 204 |   [aux_sym_quoted_attribute_value_token2] = {
 205 |     .visible = true,
 206 |     .named = true,
 207 |   },
 208 |   [sym_rust_text] = {
 209 |     .visible = true,
 210 |     .named = true,
 211 |   },
 212 |   [sym__start_tag_name] = {
 213 |     .visible = true,
 214 |     .named = true,
 215 |   },
 216 |   [sym__script_start_tag_name] = {
 217 |     .visible = true,
 218 |     .named = true,
 219 |   },
 220 |   [sym__style_start_tag_name] = {
 221 |     .visible = true,
 222 |     .named = true,
 223 |   },
 224 |   [sym__end_tag_name] = {
 225 |     .visible = true,
 226 |     .named = true,
 227 |   },
 228 |   [sym_erroneous_end_tag_name] = {
 229 |     .visible = true,
 230 |     .named = true,
 231 |   },
 232 |   [sym__implicit_end_tag] = {
 233 |     .visible = false,
 234 |     .named = true,
 235 |   },
 236 |   [sym_raw_text] = {
 237 |     .visible = true,
 238 |     .named = true,
 239 |   },
 240 |   [sym_comment] = {
 241 |     .visible = true,
 242 |     .named = true,
 243 |   },
 244 |   [sym_fragment] = {
 245 |     .visible = true,
 246 |     .named = true,
 247 |   },
 248 |   [sym__node] = {
 249 |     .visible = false,
 250 |     .named = true,
 251 |   },
 252 |   [sym_element] = {
 253 |     .visible = true,
 254 |     .named = true,
 255 |   },
 256 |   [sym_script_element] = {
 257 |     .visible = true,
 258 |     .named = true,
 259 |   },
 260 |   [sym_style_element] = {
 261 |     .visible = true,
 262 |     .named = true,
 263 |   },
 264 |   [sym_start_tag] = {
 265 |     .visible = true,
 266 |     .named = true,
 267 |   },
 268 |   [sym_script_start_tag] = {
 269 |     .visible = true,
 270 |     .named = true,
 271 |   },
 272 |   [sym_style_start_tag] = {
 273 |     .visible = true,
 274 |     .named = true,
 275 |   },
 276 |   [sym_self_closing_tag] = {
 277 |     .visible = true,
 278 |     .named = true,
 279 |   },
 280 |   [sym_end_tag] = {
 281 |     .visible = true,
 282 |     .named = true,
 283 |   },
 284 |   [sym_erroneous_end_tag] = {
 285 |     .visible = true,
 286 |     .named = true,
 287 |   },
 288 |   [sym_attribute] = {
 289 |     .visible = true,
 290 |     .named = true,
 291 |   },
 292 |   [sym_rust_attribute] = {
 293 |     .visible = true,
 294 |     .named = true,
 295 |   },
 296 |   [sym_quoted_attribute_value] = {
 297 |     .visible = true,
 298 |     .named = true,
 299 |   },
 300 |   [aux_sym_fragment_repeat1] = {
 301 |     .visible = false,
 302 |     .named = false,
 303 |   },
 304 |   [aux_sym_start_tag_repeat1] = {
 305 |     .visible = false,
 306 |     .named = false,
 307 |   },
 308 | };
 309 | 
 310 | static const TSSymbol ts_alias_sequences[PRODUCTION_ID_COUNT][MAX_ALIAS_SEQUENCE_LENGTH] = {
 311 |   [0] = {0},
 312 | };
 313 | 
 314 | static const uint16_t ts_non_terminal_alias_map[] = {
 315 |   0,
 316 | };
 317 | 
 318 | static bool ts_lex(TSLexer *lexer, TSStateId state) {
 319 |   START_LEXER();
 320 |   eof = lexer->eof(lexer);
 321 |   switch (state) {
 322 |     case 0:
 323 |       if (eof) ADVANCE(8);
 324 |       if (lookahead == '"') ADVANCE(24);
 325 |       if (lookahead == '\'') ADVANCE(21);
 326 |       if (lookahead == '/') ADVANCE(5);
 327 |       if (lookahead == '<') ADVANCE(9);
 328 |       if (lookahead == '=') ADVANCE(13);
 329 |       if (lookahead == '>') ADVANCE(10);
 330 |       if (lookahead == '{') ADVANCE(16);
 331 |       if (lookahead == '}') ADVANCE(20);
 332 |       if (lookahead == '\t' ||
 333 |           lookahead == '\n' ||
 334 |           lookahead == '\r' ||
 335 |           lookahead == ' ') SKIP(0)
 336 |       END_STATE();
 337 |     case 1:
 338 |       if (lookahead == '"') ADVANCE(24);
 339 |       if (lookahead == '\'') ADVANCE(21);
 340 |       if (lookahead == '{') ADVANCE(17);
 341 |       if (lookahead == '\t' ||
 342 |           lookahead == '\n' ||
 343 |           lookahead == '\r' ||
 344 |           lookahead == ' ') SKIP(1)
 345 |       if (lookahead != 0 &&
 346 |           (lookahead < '<' || '>' < lookahead)) ADVANCE(15);
 347 |       END_STATE();
 348 |     case 2:
 349 |       if (lookahead == '"') ADVANCE(24);
 350 |       if (lookahead == '\t' ||
 351 |           lookahead == '\n' ||
 352 |           lookahead == '\r' ||
 353 |           lookahead == ' ') ADVANCE(25);
 354 |       if (lookahead != 0) ADVANCE(26);
 355 |       END_STATE();
 356 |     case 3:
 357 |       if (lookahead == '\'') ADVANCE(21);
 358 |       if (lookahead == '\t' ||
 359 |           lookahead == '\n' ||
 360 |           lookahead == '\r' ||
 361 |           lookahead == ' ') ADVANCE(22);
 362 |       if (lookahead != 0) ADVANCE(23);
 363 |       END_STATE();
 364 |     case 4:
 365 |       if (lookahead == '/') ADVANCE(5);
 366 |       if (lookahead == '=') ADVANCE(13);
 367 |       if (lookahead == '>') ADVANCE(10);
 368 |       if (lookahead == '\t' ||
 369 |           lookahead == '\n' ||
 370 |           lookahead == '\r' ||
 371 |           lookahead == ' ') SKIP(4)
 372 |       if (lookahead != 0 &&
 373 |           lookahead != '"' &&
 374 |           lookahead != '\'' &&
 375 |           lookahead != '<') ADVANCE(14);
 376 |       END_STATE();
 377 |     case 5:
 378 |       if (lookahead == '>') ADVANCE(11);
 379 |       END_STATE();
 380 |     case 6:
 381 |       if (lookahead == '\t' ||
 382 |           lookahead == '\n' ||
 383 |           lookahead == '\r' ||
 384 |           lookahead == ' ') ADVANCE(6);
 385 |       if (lookahead != 0 &&
 386 |           lookahead != '<' &&
 387 |           lookahead != '>') ADVANCE(27);
 388 |       END_STATE();
 389 |     case 7:
 390 |       if (eof) ADVANCE(8);
 391 |       if (lookahead == '<') ADVANCE(9);
 392 |       if (lookahead == '\t' ||
 393 |           lookahead == '\n' ||
 394 |           lookahead == '\r' ||
 395 |           lookahead == ' ') SKIP(7)
 396 |       if (lookahead != 0 &&
 397 |           lookahead != '>') ADVANCE(27);
 398 |       END_STATE();
 399 |     case 8:
 400 |       ACCEPT_TOKEN(ts_builtin_sym_end);
 401 |       END_STATE();
 402 |     case 9:
 403 |       ACCEPT_TOKEN(anon_sym_LT);
 404 |       if (lookahead == '/') ADVANCE(12);
 405 |       END_STATE();
 406 |     case 10:
 407 |       ACCEPT_TOKEN(anon_sym_GT);
 408 |       END_STATE();
 409 |     case 11:
 410 |       ACCEPT_TOKEN(anon_sym_SLASH_GT);
 411 |       END_STATE();
 412 |     case 12:
 413 |       ACCEPT_TOKEN(anon_sym_LT_SLASH);
 414 |       END_STATE();
 415 |     case 13:
 416 |       ACCEPT_TOKEN(anon_sym_EQ);
 417 |       END_STATE();
 418 |     case 14:
 419 |       ACCEPT_TOKEN(sym_attribute_name);
 420 |       if (lookahead != 0 &&
 421 |           lookahead != '\t' &&
 422 |           lookahead != '\n' &&
 423 |           lookahead != '\r' &&
 424 |           lookahead != ' ' &&
 425 |           lookahead != '"' &&
 426 |           lookahead != '\'' &&
 427 |           lookahead != '/' &&
 428 |           (lookahead < '<' || '>' < lookahead)) ADVANCE(14);
 429 |       END_STATE();
 430 |     case 15:
 431 |       ACCEPT_TOKEN(sym_attribute_value);
 432 |       if (lookahead != 0 &&
 433 |           lookahead != '\t' &&
 434 |           lookahead != '\n' &&
 435 |           lookahead != '\r' &&
 436 |           lookahead != ' ' &&
 437 |           lookahead != '"' &&
 438 |           lookahead != '\'' &&
 439 |           (lookahead < '<' || '>' < lookahead)) ADVANCE(15);
 440 |       END_STATE();
 441 |     case 16:
 442 |       ACCEPT_TOKEN(anon_sym_LBRACE);
 443 |       END_STATE();
 444 |     case 17:
 445 |       ACCEPT_TOKEN(anon_sym_LBRACE);
 446 |       if (lookahead != 0 &&
 447 |           lookahead != '\t' &&
 448 |           lookahead != '\n' &&
 449 |           lookahead != '\r' &&
 450 |           lookahead != ' ' &&
 451 |           lookahead != '"' &&
 452 |           lookahead != '\'' &&
 453 |           (lookahead < '<' || '>' < lookahead)) ADVANCE(15);
 454 |       END_STATE();
 455 |     case 18:
 456 |       ACCEPT_TOKEN(aux_sym_rust_attribute_token1);
 457 |       if (lookahead == '\t' ||
 458 |           lookahead == '\n' ||
 459 |           lookahead == '\r' ||
 460 |           lookahead == ' ') ADVANCE(18);
 461 |       if (lookahead != 0 &&
 462 |           lookahead != '}') ADVANCE(19);
 463 |       END_STATE();
 464 |     case 19:
 465 |       ACCEPT_TOKEN(aux_sym_rust_attribute_token1);
 466 |       if (lookahead != 0 &&
 467 |           lookahead != '}') ADVANCE(19);
 468 |       END_STATE();
 469 |     case 20:
 470 |       ACCEPT_TOKEN(anon_sym_RBRACE);
 471 |       END_STATE();
 472 |     case 21:
 473 |       ACCEPT_TOKEN(anon_sym_SQUOTE);
 474 |       END_STATE();
 475 |     case 22:
 476 |       ACCEPT_TOKEN(aux_sym_quoted_attribute_value_token1);
 477 |       if (lookahead == '\t' ||
 478 |           lookahead == '\n' ||
 479 |           lookahead == '\r' ||
 480 |           lookahead == ' ') ADVANCE(22);
 481 |       if (lookahead != 0 &&
 482 |           lookahead != '\'') ADVANCE(23);
 483 |       END_STATE();
 484 |     case 23:
 485 |       ACCEPT_TOKEN(aux_sym_quoted_attribute_value_token1);
 486 |       if (lookahead != 0 &&
 487 |           lookahead != '\'') ADVANCE(23);
 488 |       END_STATE();
 489 |     case 24:
 490 |       ACCEPT_TOKEN(anon_sym_DQUOTE);
 491 |       END_STATE();
 492 |     case 25:
 493 |       ACCEPT_TOKEN(aux_sym_quoted_attribute_value_token2);
 494 |       if (lookahead == '\t' ||
 495 |           lookahead == '\n' ||
 496 |           lookahead == '\r' ||
 497 |           lookahead == ' ') ADVANCE(25);
 498 |       if (lookahead != 0 &&
 499 |           lookahead != '"') ADVANCE(26);
 500 |       END_STATE();
 501 |     case 26:
 502 |       ACCEPT_TOKEN(aux_sym_quoted_attribute_value_token2);
 503 |       if (lookahead != 0 &&
 504 |           lookahead != '"') ADVANCE(26);
 505 |       END_STATE();
 506 |     case 27:
 507 |       ACCEPT_TOKEN(sym_rust_text);
 508 |       if (lookahead == '\t' ||
 509 |           lookahead == '\n' ||
 510 |           lookahead == '\r' ||
 511 |           lookahead == ' ') ADVANCE(6);
 512 |       if (lookahead != 0 &&
 513 |           lookahead != '<' &&
 514 |           lookahead != '>') ADVANCE(27);
 515 |       END_STATE();
 516 |     default:
 517 |       return false;
 518 |   }
 519 | }
 520 | 
 521 | static const TSLexMode ts_lex_modes[STATE_COUNT] = {
 522 |   [0] = {.lex_state = 0, .external_lex_state = 1},
 523 |   [1] = {.lex_state = 7, .external_lex_state = 2},
 524 |   [2] = {.lex_state = 7, .external_lex_state = 3},
 525 |   [3] = {.lex_state = 7, .external_lex_state = 3},
 526 |   [4] = {.lex_state = 7, .external_lex_state = 3},
 527 |   [5] = {.lex_state = 7, .external_lex_state = 3},
 528 |   [6] = {.lex_state = 7, .external_lex_state = 2},
 529 |   [7] = {.lex_state = 7, .external_lex_state = 3},
 530 |   [8] = {.lex_state = 7, .external_lex_state = 2},
 531 |   [9] = {.lex_state = 1, .external_lex_state = 2},
 532 |   [10] = {.lex_state = 1, .external_lex_state = 2},
 533 |   [11] = {.lex_state = 4, .external_lex_state = 4},
 534 |   [12] = {.lex_state = 4, .external_lex_state = 4},
 535 |   [13] = {.lex_state = 4, .external_lex_state = 4},
 536 |   [14] = {.lex_state = 4, .external_lex_state = 4},
 537 |   [15] = {.lex_state = 4, .external_lex_state = 4},
 538 |   [16] = {.lex_state = 4, .external_lex_state = 2},
 539 |   [17] = {.lex_state = 7, .external_lex_state = 3},
 540 |   [18] = {.lex_state = 7, .external_lex_state = 3},
 541 |   [19] = {.lex_state = 4, .external_lex_state = 2},
 542 |   [20] = {.lex_state = 7, .external_lex_state = 2},
 543 |   [21] = {.lex_state = 7, .external_lex_state = 3},
 544 |   [22] = {.lex_state = 7, .external_lex_state = 2},
 545 |   [23] = {.lex_state = 7, .external_lex_state = 3},
 546 |   [24] = {.lex_state = 7, .external_lex_state = 2},
 547 |   [25] = {.lex_state = 7, .external_lex_state = 3},
 548 |   [26] = {.lex_state = 7, .external_lex_state = 2},
 549 |   [27] = {.lex_state = 4, .external_lex_state = 4},
 550 |   [28] = {.lex_state = 7, .external_lex_state = 3},
 551 |   [29] = {.lex_state = 7, .external_lex_state = 3},
 552 |   [30] = {.lex_state = 4, .external_lex_state = 2},
 553 |   [31] = {.lex_state = 7, .external_lex_state = 2},
 554 |   [32] = {.lex_state = 4, .external_lex_state = 2},
 555 |   [33] = {.lex_state = 7, .external_lex_state = 2},
 556 |   [34] = {.lex_state = 7, .external_lex_state = 2},
 557 |   [35] = {.lex_state = 7, .external_lex_state = 2},
 558 |   [36] = {.lex_state = 7, .external_lex_state = 2},
 559 |   [37] = {.lex_state = 7, .external_lex_state = 3},
 560 |   [38] = {.lex_state = 7, .external_lex_state = 2},
 561 |   [39] = {.lex_state = 7, .external_lex_state = 3},
 562 |   [40] = {.lex_state = 7, .external_lex_state = 3},
 563 |   [41] = {.lex_state = 7, .external_lex_state = 3},
 564 |   [42] = {.lex_state = 7, .external_lex_state = 2},
 565 |   [43] = {.lex_state = 4, .external_lex_state = 2},
 566 |   [44] = {.lex_state = 7, .external_lex_state = 3},
 567 |   [45] = {.lex_state = 7, .external_lex_state = 3},
 568 |   [46] = {.lex_state = 4, .external_lex_state = 4},
 569 |   [47] = {.lex_state = 0, .external_lex_state = 5},
 570 |   [48] = {.lex_state = 4, .external_lex_state = 4},
 571 |   [49] = {.lex_state = 4, .external_lex_state = 4},
 572 |   [50] = {.lex_state = 4, .external_lex_state = 4},
 573 |   [51] = {.lex_state = 0, .external_lex_state = 6},
 574 |   [52] = {.lex_state = 4, .external_lex_state = 2},
 575 |   [53] = {.lex_state = 0, .external_lex_state = 6},
 576 |   [54] = {.lex_state = 0, .external_lex_state = 6},
 577 |   [55] = {.lex_state = 0, .external_lex_state = 5},
 578 |   [56] = {.lex_state = 0, .external_lex_state = 6},
 579 |   [57] = {.lex_state = 2, .external_lex_state = 2},
 580 |   [58] = {.lex_state = 0, .external_lex_state = 2},
 581 |   [59] = {.lex_state = 0, .external_lex_state = 7},
 582 |   [60] = {.lex_state = 2, .external_lex_state = 2},
 583 |   [61] = {.lex_state = 3, .external_lex_state = 2},
 584 |   [62] = {.lex_state = 3, .external_lex_state = 2},
 585 |   [63] = {.lex_state = 0, .external_lex_state = 7},
 586 |   [64] = {.lex_state = 0, .external_lex_state = 6},
 587 |   [65] = {.lex_state = 0, .external_lex_state = 6},
 588 |   [66] = {.lex_state = 0, .external_lex_state = 2},
 589 |   [67] = {.lex_state = 4, .external_lex_state = 2},
 590 |   [68] = {.lex_state = 4, .external_lex_state = 2},
 591 |   [69] = {.lex_state = 4, .external_lex_state = 2},
 592 |   [70] = {.lex_state = 4, .external_lex_state = 2},
 593 |   [71] = {.lex_state = 0, .external_lex_state = 6},
 594 |   [72] = {.lex_state = 0, .external_lex_state = 6},
 595 |   [73] = {.lex_state = 0, .external_lex_state = 2},
 596 |   [74] = {.lex_state = 0, .external_lex_state = 2},
 597 |   [75] = {.lex_state = 0, .external_lex_state = 2},
 598 |   [76] = {.lex_state = 0, .external_lex_state = 8},
 599 |   [77] = {.lex_state = 0, .external_lex_state = 2},
 600 |   [78] = {.lex_state = 0, .external_lex_state = 2},
 601 |   [79] = {.lex_state = 0, .external_lex_state = 2},
 602 |   [80] = {.lex_state = 0, .external_lex_state = 2},
 603 |   [81] = {.lex_state = 0, .external_lex_state = 2},
 604 |   [82] = {.lex_state = 18, .external_lex_state = 2},
 605 |   [83] = {.lex_state = 0, .external_lex_state = 2},
 606 |   [84] = {.lex_state = 0, .external_lex_state = 2},
 607 |   [85] = {.lex_state = 0, .external_lex_state = 2},
 608 |   [86] = {.lex_state = 0, .external_lex_state = 2},
 609 |   [87] = {.lex_state = 0, .external_lex_state = 2},
 610 |   [88] = {.lex_state = 0, .external_lex_state = 9},
 611 |   [89] = {.lex_state = 0, .external_lex_state = 9},
 612 |   [90] = {.lex_state = 0, .external_lex_state = 8},
 613 |   [91] = {.lex_state = 18, .external_lex_state = 2},
 614 | };
 615 | 
 616 | enum {
 617 |   ts_external_token__start_tag_name = 0,
 618 |   ts_external_token__script_start_tag_name = 1,
 619 |   ts_external_token__style_start_tag_name = 2,
 620 |   ts_external_token__end_tag_name = 3,
 621 |   ts_external_token_erroneous_end_tag_name = 4,
 622 |   ts_external_token_SLASH_GT = 5,
 623 |   ts_external_token__implicit_end_tag = 6,
 624 |   ts_external_token_raw_text = 7,
 625 |   ts_external_token_comment = 8,
 626 | };
 627 | 
 628 | static const TSSymbol ts_external_scanner_symbol_map[EXTERNAL_TOKEN_COUNT] = {
 629 |   [ts_external_token__start_tag_name] = sym__start_tag_name,
 630 |   [ts_external_token__script_start_tag_name] = sym__script_start_tag_name,
 631 |   [ts_external_token__style_start_tag_name] = sym__style_start_tag_name,
 632 |   [ts_external_token__end_tag_name] = sym__end_tag_name,
 633 |   [ts_external_token_erroneous_end_tag_name] = sym_erroneous_end_tag_name,
 634 |   [ts_external_token_SLASH_GT] = anon_sym_SLASH_GT,
 635 |   [ts_external_token__implicit_end_tag] = sym__implicit_end_tag,
 636 |   [ts_external_token_raw_text] = sym_raw_text,
 637 |   [ts_external_token_comment] = sym_comment,
 638 | };
 639 | 
 640 | static const bool ts_external_scanner_states[10][EXTERNAL_TOKEN_COUNT] = {
 641 |   [1] = {
 642 |     [ts_external_token__start_tag_name] = true,
 643 |     [ts_external_token__script_start_tag_name] = true,
 644 |     [ts_external_token__style_start_tag_name] = true,
 645 |     [ts_external_token__end_tag_name] = true,
 646 |     [ts_external_token_erroneous_end_tag_name] = true,
 647 |     [ts_external_token_SLASH_GT] = true,
 648 |     [ts_external_token__implicit_end_tag] = true,
 649 |     [ts_external_token_raw_text] = true,
 650 |     [ts_external_token_comment] = true,
 651 |   },
 652 |   [2] = {
 653 |     [ts_external_token_comment] = true,
 654 |   },
 655 |   [3] = {
 656 |     [ts_external_token__implicit_end_tag] = true,
 657 |     [ts_external_token_comment] = true,
 658 |   },
 659 |   [4] = {
 660 |     [ts_external_token_SLASH_GT] = true,
 661 |     [ts_external_token_comment] = true,
 662 |   },
 663 |   [5] = {
 664 |     [ts_external_token__start_tag_name] = true,
 665 |     [ts_external_token__script_start_tag_name] = true,
 666 |     [ts_external_token__style_start_tag_name] = true,
 667 |     [ts_external_token_comment] = true,
 668 |   },
 669 |   [6] = {
 670 |     [ts_external_token_raw_text] = true,
 671 |     [ts_external_token_comment] = true,
 672 |   },
 673 |   [7] = {
 674 |     [ts_external_token__end_tag_name] = true,
 675 |     [ts_external_token_erroneous_end_tag_name] = true,
 676 |     [ts_external_token_comment] = true,
 677 |   },
 678 |   [8] = {
 679 |     [ts_external_token__end_tag_name] = true,
 680 |     [ts_external_token_comment] = true,
 681 |   },
 682 |   [9] = {
 683 |     [ts_external_token_erroneous_end_tag_name] = true,
 684 |     [ts_external_token_comment] = true,
 685 |   },
 686 | };
 687 | 
 688 | static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
 689 |   [0] = {
 690 |     [ts_builtin_sym_end] = ACTIONS(1),
 691 |     [anon_sym_LT] = ACTIONS(1),
 692 |     [anon_sym_GT] = ACTIONS(1),
 693 |     [anon_sym_SLASH_GT] = ACTIONS(1),
 694 |     [anon_sym_LT_SLASH] = ACTIONS(1),
 695 |     [anon_sym_EQ] = ACTIONS(1),
 696 |     [anon_sym_LBRACE] = ACTIONS(1),
 697 |     [anon_sym_RBRACE] = ACTIONS(1),
 698 |     [anon_sym_SQUOTE] = ACTIONS(1),
 699 |     [anon_sym_DQUOTE] = ACTIONS(1),
 700 |     [sym__start_tag_name] = ACTIONS(1),
 701 |     [sym__script_start_tag_name] = ACTIONS(1),
 702 |     [sym__style_start_tag_name] = ACTIONS(1),
 703 |     [sym__end_tag_name] = ACTIONS(1),
 704 |     [sym_erroneous_end_tag_name] = ACTIONS(1),
 705 |     [sym__implicit_end_tag] = ACTIONS(1),
 706 |     [sym_raw_text] = ACTIONS(1),
 707 |     [sym_comment] = ACTIONS(3),
 708 |   },
 709 |   [1] = {
 710 |     [sym_fragment] = STATE(87),
 711 |     [sym__node] = STATE(6),
 712 |     [sym_element] = STATE(6),
 713 |     [sym_script_element] = STATE(6),
 714 |     [sym_style_element] = STATE(6),
 715 |     [sym_start_tag] = STATE(3),
 716 |     [sym_script_start_tag] = STATE(51),
 717 |     [sym_style_start_tag] = STATE(56),
 718 |     [sym_self_closing_tag] = STATE(36),
 719 |     [sym_erroneous_end_tag] = STATE(6),
 720 |     [aux_sym_fragment_repeat1] = STATE(6),
 721 |     [ts_builtin_sym_end] = ACTIONS(5),
 722 |     [anon_sym_LT] = ACTIONS(7),
 723 |     [anon_sym_LT_SLASH] = ACTIONS(9),
 724 |     [sym_rust_text] = ACTIONS(11),
 725 |     [sym_comment] = ACTIONS(3),
 726 |   },
 727 | };
 728 | 
 729 | static const uint16_t ts_small_parse_table[] = {
 730 |   [0] = 11,
 731 |     ACTIONS(3), 1,
 732 |       sym_comment,
 733 |     ACTIONS(13), 1,
 734 |       anon_sym_LT,
 735 |     ACTIONS(15), 1,
 736 |       anon_sym_LT_SLASH,
 737 |     ACTIONS(17), 1,
 738 |       sym_rust_text,
 739 |     ACTIONS(19), 1,
 740 |       sym__implicit_end_tag,
 741 |     STATE(4), 1,
 742 |       sym_start_tag,
 743 |     STATE(33), 1,
 744 |       sym_end_tag,
 745 |     STATE(37), 1,
 746 |       sym_self_closing_tag,
 747 |     STATE(53), 1,
 748 |       sym_script_start_tag,
 749 |     STATE(54), 1,
 750 |       sym_style_start_tag,
 751 |     STATE(7), 6,
 752 |       sym__node,
 753 |       sym_element,
 754 |       sym_script_element,
 755 |       sym_style_element,
 756 |       sym_erroneous_end_tag,
 757 |       aux_sym_fragment_repeat1,
 758 |   [39] = 11,
 759 |     ACTIONS(3), 1,
 760 |       sym_comment,
 761 |     ACTIONS(13), 1,
 762 |       anon_sym_LT,
 763 |     ACTIONS(15), 1,
 764 |       anon_sym_LT_SLASH,
 765 |     ACTIONS(21), 1,
 766 |       sym_rust_text,
 767 |     ACTIONS(23), 1,
 768 |       sym__implicit_end_tag,
 769 |     STATE(4), 1,
 770 |       sym_start_tag,
 771 |     STATE(20), 1,
 772 |       sym_end_tag,
 773 |     STATE(37), 1,
 774 |       sym_self_closing_tag,
 775 |     STATE(53), 1,
 776 |       sym_script_start_tag,
 777 |     STATE(54), 1,
 778 |       sym_style_start_tag,
 779 |     STATE(2), 6,
 780 |       sym__node,
 781 |       sym_element,
 782 |       sym_script_element,
 783 |       sym_style_element,
 784 |       sym_erroneous_end_tag,
 785 |       aux_sym_fragment_repeat1,
 786 |   [78] = 11,
 787 |     ACTIONS(3), 1,
 788 |       sym_comment,
 789 |     ACTIONS(13), 1,
 790 |       anon_sym_LT,
 791 |     ACTIONS(25), 1,
 792 |       anon_sym_LT_SLASH,
 793 |     ACTIONS(27), 1,
 794 |       sym_rust_text,
 795 |     ACTIONS(29), 1,
 796 |       sym__implicit_end_tag,
 797 |     STATE(4), 1,
 798 |       sym_start_tag,
 799 |     STATE(28), 1,
 800 |       sym_end_tag,
 801 |     STATE(37), 1,
 802 |       sym_self_closing_tag,
 803 |     STATE(53), 1,
 804 |       sym_script_start_tag,
 805 |     STATE(54), 1,
 806 |       sym_style_start_tag,
 807 |     STATE(5), 6,
 808 |       sym__node,
 809 |       sym_element,
 810 |       sym_script_element,
 811 |       sym_style_element,
 812 |       sym_erroneous_end_tag,
 813 |       aux_sym_fragment_repeat1,
 814 |   [117] = 11,
 815 |     ACTIONS(3), 1,
 816 |       sym_comment,
 817 |     ACTIONS(13), 1,
 818 |       anon_sym_LT,
 819 |     ACTIONS(17), 1,
 820 |       sym_rust_text,
 821 |     ACTIONS(25), 1,
 822 |       anon_sym_LT_SLASH,
 823 |     ACTIONS(31), 1,
 824 |       sym__implicit_end_tag,
 825 |     STATE(4), 1,
 826 |       sym_start_tag,
 827 |     STATE(37), 1,
 828 |       sym_self_closing_tag,
 829 |     STATE(45), 1,
 830 |       sym_end_tag,
 831 |     STATE(53), 1,
 832 |       sym_script_start_tag,
 833 |     STATE(54), 1,
 834 |       sym_style_start_tag,
 835 |     STATE(7), 6,
 836 |       sym__node,
 837 |       sym_element,
 838 |       sym_script_element,
 839 |       sym_style_element,
 840 |       sym_erroneous_end_tag,
 841 |       aux_sym_fragment_repeat1,
 842 |   [156] = 10,
 843 |     ACTIONS(3), 1,
 844 |       sym_comment,
 845 |     ACTIONS(7), 1,
 846 |       anon_sym_LT,
 847 |     ACTIONS(9), 1,
 848 |       anon_sym_LT_SLASH,
 849 |     ACTIONS(33), 1,
 850 |       ts_builtin_sym_end,
 851 |     ACTIONS(35), 1,
 852 |       sym_rust_text,
 853 |     STATE(3), 1,
 854 |       sym_start_tag,
 855 |     STATE(36), 1,
 856 |       sym_self_closing_tag,
 857 |     STATE(51), 1,
 858 |       sym_script_start_tag,
 859 |     STATE(56), 1,
 860 |       sym_style_start_tag,
 861 |     STATE(8), 6,
 862 |       sym__node,
 863 |       sym_element,
 864 |       sym_script_element,
 865 |       sym_style_element,
 866 |       sym_erroneous_end_tag,
 867 |       aux_sym_fragment_repeat1,
 868 |   [192] = 10,
 869 |     ACTIONS(3), 1,
 870 |       sym_comment,
 871 |     ACTIONS(37), 1,
 872 |       anon_sym_LT,
 873 |     ACTIONS(40), 1,
 874 |       anon_sym_LT_SLASH,
 875 |     ACTIONS(43), 1,
 876 |       sym_rust_text,
 877 |     ACTIONS(46), 1,
 878 |       sym__implicit_end_tag,
 879 |     STATE(4), 1,
 880 |       sym_start_tag,
 881 |     STATE(37), 1,
 882 |       sym_self_closing_tag,
 883 |     STATE(53), 1,
 884 |       sym_script_start_tag,
 885 |     STATE(54), 1,
 886 |       sym_style_start_tag,
 887 |     STATE(7), 6,
 888 |       sym__node,
 889 |       sym_element,
 890 |       sym_script_element,
 891 |       sym_style_element,
 892 |       sym_erroneous_end_tag,
 893 |       aux_sym_fragment_repeat1,
 894 |   [228] = 10,
 895 |     ACTIONS(3), 1,
 896 |       sym_comment,
 897 |     ACTIONS(46), 1,
 898 |       ts_builtin_sym_end,
 899 |     ACTIONS(48), 1,
 900 |       anon_sym_LT,
 901 |     ACTIONS(51), 1,
 902 |       anon_sym_LT_SLASH,
 903 |     ACTIONS(54), 1,
 904 |       sym_rust_text,
 905 |     STATE(3), 1,
 906 |       sym_start_tag,
 907 |     STATE(36), 1,
 908 |       sym_self_closing_tag,
 909 |     STATE(51), 1,
 910 |       sym_script_start_tag,
 911 |     STATE(56), 1,
 912 |       sym_style_start_tag,
 913 |     STATE(8), 6,
 914 |       sym__node,
 915 |       sym_element,
 916 |       sym_script_element,
 917 |       sym_style_element,
 918 |       sym_erroneous_end_tag,
 919 |       aux_sym_fragment_repeat1,
 920 |   [264] = 6,
 921 |     ACTIONS(3), 1,
 922 |       sym_comment,
 923 |     ACTIONS(57), 1,
 924 |       sym_attribute_value,
 925 |     ACTIONS(59), 1,
 926 |       anon_sym_LBRACE,
 927 |     ACTIONS(61), 1,
 928 |       anon_sym_SQUOTE,
 929 |     ACTIONS(63), 1,
 930 |       anon_sym_DQUOTE,
 931 |     STATE(46), 2,
 932 |       sym_rust_attribute,
 933 |       sym_quoted_attribute_value,
 934 |   [284] = 6,
 935 |     ACTIONS(3), 1,
 936 |       sym_comment,
 937 |     ACTIONS(65), 1,
 938 |       sym_attribute_value,
 939 |     ACTIONS(67), 1,
 940 |       anon_sym_LBRACE,
 941 |     ACTIONS(69), 1,
 942 |       anon_sym_SQUOTE,
 943 |     ACTIONS(71), 1,
 944 |       anon_sym_DQUOTE,
 945 |     STATE(67), 2,
 946 |       sym_rust_attribute,
 947 |       sym_quoted_attribute_value,
 948 |   [304] = 5,
 949 |     ACTIONS(3), 1,
 950 |       sym_comment,
 951 |     ACTIONS(73), 1,
 952 |       anon_sym_GT,
 953 |     ACTIONS(75), 1,
 954 |       anon_sym_SLASH_GT,
 955 |     ACTIONS(77), 1,
 956 |       sym_attribute_name,
 957 |     STATE(14), 2,
 958 |       sym_attribute,
 959 |       aux_sym_start_tag_repeat1,
 960 |   [321] = 4,
 961 |     ACTIONS(3), 1,
 962 |       sym_comment,
 963 |     ACTIONS(81), 1,
 964 |       sym_attribute_name,
 965 |     ACTIONS(79), 2,
 966 |       anon_sym_GT,
 967 |       anon_sym_SLASH_GT,
 968 |     STATE(12), 2,
 969 |       sym_attribute,
 970 |       aux_sym_start_tag_repeat1,
 971 |   [336] = 5,
 972 |     ACTIONS(3), 1,
 973 |       sym_comment,
 974 |     ACTIONS(73), 1,
 975 |       anon_sym_GT,
 976 |     ACTIONS(77), 1,
 977 |       sym_attribute_name,
 978 |     ACTIONS(84), 1,
 979 |       anon_sym_SLASH_GT,
 980 |     STATE(15), 2,
 981 |       sym_attribute,
 982 |       aux_sym_start_tag_repeat1,
 983 |   [353] = 5,
 984 |     ACTIONS(3), 1,
 985 |       sym_comment,
 986 |     ACTIONS(77), 1,
 987 |       sym_attribute_name,
 988 |     ACTIONS(86), 1,
 989 |       anon_sym_GT,
 990 |     ACTIONS(88), 1,
 991 |       anon_sym_SLASH_GT,
 992 |     STATE(12), 2,
 993 |       sym_attribute,
 994 |       aux_sym_start_tag_repeat1,
 995 |   [370] = 5,
 996 |     ACTIONS(3), 1,
 997 |       sym_comment,
 998 |     ACTIONS(77), 1,
 999 |       sym_attribute_name,
1000 |     ACTIONS(86), 1,
1001 |       anon_sym_GT,
1002 |     ACTIONS(90), 1,
1003 |       anon_sym_SLASH_GT,
1004 |     STATE(12), 2,
1005 |       sym_attribute,
1006 |       aux_sym_start_tag_repeat1,
1007 |   [387] = 4,
1008 |     ACTIONS(3), 1,
1009 |       sym_comment,
1010 |     ACTIONS(92), 1,
1011 |       anon_sym_GT,
1012 |     ACTIONS(94), 1,
1013 |       sym_attribute_name,
1014 |     STATE(32), 2,
1015 |       sym_attribute,
1016 |       aux_sym_start_tag_repeat1,
1017 |   [401] = 3,
1018 |     ACTIONS(3), 1,
1019 |       sym_comment,
1020 |     ACTIONS(96), 1,
1021 |       anon_sym_LT,
1022 |     ACTIONS(98), 3,
1023 |       sym__implicit_end_tag,
1024 |       anon_sym_LT_SLASH,
1025 |       sym_rust_text,
1026 |   [413] = 3,
1027 |     ACTIONS(3), 1,
1028 |       sym_comment,
1029 |     ACTIONS(100), 1,
1030 |       anon_sym_LT,
1031 |     ACTIONS(102), 3,
1032 |       sym__implicit_end_tag,
1033 |       anon_sym_LT_SLASH,
1034 |       sym_rust_text,
1035 |   [425] = 4,
1036 |     ACTIONS(3), 1,
1037 |       sym_comment,
1038 |     ACTIONS(94), 1,
1039 |       sym_attribute_name,
1040 |     ACTIONS(104), 1,
1041 |       anon_sym_GT,
1042 |     STATE(16), 2,
1043 |       sym_attribute,
1044 |       aux_sym_start_tag_repeat1,
1045 |   [439] = 3,
1046 |     ACTIONS(3), 1,
1047 |       sym_comment,
1048 |     ACTIONS(108), 1,
1049 |       anon_sym_LT,
1050 |     ACTIONS(106), 3,
1051 |       ts_builtin_sym_end,
1052 |       anon_sym_LT_SLASH,
1053 |       sym_rust_text,
1054 |   [451] = 3,
1055 |     ACTIONS(3), 1,
1056 |       sym_comment,
1057 |     ACTIONS(110), 1,
1058 |       anon_sym_LT,
1059 |     ACTIONS(112), 3,
1060 |       sym__implicit_end_tag,
1061 |       anon_sym_LT_SLASH,
1062 |       sym_rust_text,
1063 |   [463] = 3,
1064 |     ACTIONS(3), 1,
1065 |       sym_comment,
1066 |     ACTIONS(116), 1,
1067 |       anon_sym_LT,
1068 |     ACTIONS(114), 3,
1069 |       ts_builtin_sym_end,
1070 |       anon_sym_LT_SLASH,
1071 |       sym_rust_text,
1072 |   [475] = 3,
1073 |     ACTIONS(3), 1,
1074 |       sym_comment,
1075 |     ACTIONS(116), 1,
1076 |       anon_sym_LT,
1077 |     ACTIONS(114), 3,
1078 |       sym__implicit_end_tag,
1079 |       anon_sym_LT_SLASH,
1080 |       sym_rust_text,
1081 |   [487] = 3,
1082 |     ACTIONS(3), 1,
1083 |       sym_comment,
1084 |     ACTIONS(110), 1,
1085 |       anon_sym_LT,
1086 |     ACTIONS(112), 3,
1087 |       ts_builtin_sym_end,
1088 |       anon_sym_LT_SLASH,
1089 |       sym_rust_text,
1090 |   [499] = 3,
1091 |     ACTIONS(3), 1,
1092 |       sym_comment,
1093 |     ACTIONS(118), 1,
1094 |       anon_sym_LT,
1095 |     ACTIONS(120), 3,
1096 |       sym__implicit_end_tag,
1097 |       anon_sym_LT_SLASH,
1098 |       sym_rust_text,
1099 |   [511] = 3,
1100 |     ACTIONS(3), 1,
1101 |       sym_comment,
1102 |     ACTIONS(100), 1,
1103 |       anon_sym_LT,
1104 |     ACTIONS(102), 3,
1105 |       ts_builtin_sym_end,
1106 |       anon_sym_LT_SLASH,
1107 |       sym_rust_text,
1108 |   [523] = 3,
1109 |     ACTIONS(3), 1,
1110 |       sym_comment,
1111 |     ACTIONS(124), 1,
1112 |       anon_sym_EQ,
1113 |     ACTIONS(122), 3,
1114 |       anon_sym_GT,
1115 |       anon_sym_SLASH_GT,
1116 |       sym_attribute_name,
1117 |   [535] = 3,
1118 |     ACTIONS(3), 1,
1119 |       sym_comment,
1120 |     ACTIONS(108), 1,
1121 |       anon_sym_LT,
1122 |     ACTIONS(106), 3,
1123 |       sym__implicit_end_tag,
1124 |       anon_sym_LT_SLASH,
1125 |       sym_rust_text,
1126 |   [547] = 3,
1127 |     ACTIONS(3), 1,
1128 |       sym_comment,
1129 |     ACTIONS(126), 1,
1130 |       anon_sym_LT,
1131 |     ACTIONS(128), 3,
1132 |       sym__implicit_end_tag,
1133 |       anon_sym_LT_SLASH,
1134 |       sym_rust_text,
1135 |   [559] = 4,
1136 |     ACTIONS(3), 1,
1137 |       sym_comment,
1138 |     ACTIONS(94), 1,
1139 |       sym_attribute_name,
1140 |     ACTIONS(130), 1,
1141 |       anon_sym_GT,
1142 |     STATE(32), 2,
1143 |       sym_attribute,
1144 |       aux_sym_start_tag_repeat1,
1145 |   [573] = 3,
1146 |     ACTIONS(3), 1,
1147 |       sym_comment,
1148 |     ACTIONS(134), 1,
1149 |       anon_sym_LT,
1150 |     ACTIONS(132), 3,
1151 |       ts_builtin_sym_end,
1152 |       anon_sym_LT_SLASH,
1153 |       sym_rust_text,
1154 |   [585] = 4,
1155 |     ACTIONS(3), 1,
1156 |       sym_comment,
1157 |     ACTIONS(79), 1,
1158 |       anon_sym_GT,
1159 |     ACTIONS(136), 1,
1160 |       sym_attribute_name,
1161 |     STATE(32), 2,
1162 |       sym_attribute,
1163 |       aux_sym_start_tag_repeat1,
1164 |   [599] = 3,
1165 |     ACTIONS(3), 1,
1166 |       sym_comment,
1167 |     ACTIONS(141), 1,
1168 |       anon_sym_LT,
1169 |     ACTIONS(139), 3,
1170 |       ts_builtin_sym_end,
1171 |       anon_sym_LT_SLASH,
1172 |       sym_rust_text,
1173 |   [611] = 3,
1174 |     ACTIONS(3), 1,
1175 |       sym_comment,
1176 |     ACTIONS(145), 1,
1177 |       anon_sym_LT,
1178 |     ACTIONS(143), 3,
1179 |       ts_builtin_sym_end,
1180 |       anon_sym_LT_SLASH,
1181 |       sym_rust_text,
1182 |   [623] = 3,
1183 |     ACTIONS(3), 1,
1184 |       sym_comment,
1185 |     ACTIONS(149), 1,
1186 |       anon_sym_LT,
1187 |     ACTIONS(147), 3,
1188 |       ts_builtin_sym_end,
1189 |       anon_sym_LT_SLASH,
1190 |       sym_rust_text,
1191 |   [635] = 3,
1192 |     ACTIONS(3), 1,
1193 |       sym_comment,
1194 |     ACTIONS(153), 1,
1195 |       anon_sym_LT,
1196 |     ACTIONS(151), 3,
1197 |       ts_builtin_sym_end,
1198 |       anon_sym_LT_SLASH,
1199 |       sym_rust_text,
1200 |   [647] = 3,
1201 |     ACTIONS(3), 1,
1202 |       sym_comment,
1203 |     ACTIONS(153), 1,
1204 |       anon_sym_LT,
1205 |     ACTIONS(151), 3,
1206 |       sym__implicit_end_tag,
1207 |       anon_sym_LT_SLASH,
1208 |       sym_rust_text,
1209 |   [659] = 3,
1210 |     ACTIONS(3), 1,
1211 |       sym_comment,
1212 |     ACTIONS(157), 1,
1213 |       anon_sym_LT,
1214 |     ACTIONS(155), 3,
1215 |       ts_builtin_sym_end,
1216 |       anon_sym_LT_SLASH,
1217 |       sym_rust_text,
1218 |   [671] = 3,
1219 |     ACTIONS(3), 1,
1220 |       sym_comment,
1221 |     ACTIONS(134), 1,
1222 |       anon_sym_LT,
1223 |     ACTIONS(132), 3,
1224 |       sym__implicit_end_tag,
1225 |       anon_sym_LT_SLASH,
1226 |       sym_rust_text,
1227 |   [683] = 3,
1228 |     ACTIONS(3), 1,
1229 |       sym_comment,
1230 |     ACTIONS(157), 1,
1231 |       anon_sym_LT,
1232 |     ACTIONS(155), 3,
1233 |       sym__implicit_end_tag,
1234 |       anon_sym_LT_SLASH,
1235 |       sym_rust_text,
1236 |   [695] = 3,
1237 |     ACTIONS(3), 1,
1238 |       sym_comment,
1239 |     ACTIONS(149), 1,
1240 |       anon_sym_LT,
1241 |     ACTIONS(147), 3,
1242 |       sym__implicit_end_tag,
1243 |       anon_sym_LT_SLASH,
1244 |       sym_rust_text,
1245 |   [707] = 3,
1246 |     ACTIONS(3), 1,
1247 |       sym_comment,
1248 |     ACTIONS(126), 1,
1249 |       anon_sym_LT,
1250 |     ACTIONS(128), 3,
1251 |       ts_builtin_sym_end,
1252 |       anon_sym_LT_SLASH,
1253 |       sym_rust_text,
1254 |   [719] = 4,
1255 |     ACTIONS(3), 1,
1256 |       sym_comment,
1257 |     ACTIONS(94), 1,
1258 |       sym_attribute_name,
1259 |     ACTIONS(159), 1,
1260 |       anon_sym_GT,
1261 |     STATE(30), 2,
1262 |       sym_attribute,
1263 |       aux_sym_start_tag_repeat1,
1264 |   [733] = 3,
1265 |     ACTIONS(3), 1,
1266 |       sym_comment,
1267 |     ACTIONS(145), 1,
1268 |       anon_sym_LT,
1269 |     ACTIONS(143), 3,
1270 |       sym__implicit_end_tag,
1271 |       anon_sym_LT_SLASH,
1272 |       sym_rust_text,
1273 |   [745] = 3,
1274 |     ACTIONS(3), 1,
1275 |       sym_comment,
1276 |     ACTIONS(141), 1,
1277 |       anon_sym_LT,
1278 |     ACTIONS(139), 3,
1279 |       sym__implicit_end_tag,
1280 |       anon_sym_LT_SLASH,
1281 |       sym_rust_text,
1282 |   [757] = 2,
1283 |     ACTIONS(3), 1,
1284 |       sym_comment,
1285 |     ACTIONS(161), 3,
1286 |       anon_sym_GT,
1287 |       anon_sym_SLASH_GT,
1288 |       sym_attribute_name,
1289 |   [766] = 4,
1290 |     ACTIONS(3), 1,
1291 |       sym_comment,
1292 |     ACTIONS(163), 1,
1293 |       sym__start_tag_name,
1294 |     ACTIONS(165), 1,
1295 |       sym__script_start_tag_name,
1296 |     ACTIONS(167), 1,
1297 |       sym__style_start_tag_name,
1298 |   [779] = 2,
1299 |     ACTIONS(3), 1,
1300 |       sym_comment,
1301 |     ACTIONS(169), 3,
1302 |       anon_sym_GT,
1303 |       anon_sym_SLASH_GT,
1304 |       sym_attribute_name,
1305 |   [788] = 2,
1306 |     ACTIONS(3), 1,
1307 |       sym_comment,
1308 |     ACTIONS(171), 3,
1309 |       anon_sym_GT,
1310 |       anon_sym_SLASH_GT,
1311 |       sym_attribute_name,
1312 |   [797] = 2,
1313 |     ACTIONS(3), 1,
1314 |       sym_comment,
1315 |     ACTIONS(173), 3,
1316 |       anon_sym_GT,
1317 |       anon_sym_SLASH_GT,
1318 |       sym_attribute_name,
1319 |   [806] = 4,
1320 |     ACTIONS(3), 1,
1321 |       sym_comment,
1322 |     ACTIONS(175), 1,
1323 |       anon_sym_LT_SLASH,
1324 |     ACTIONS(177), 1,
1325 |       sym_raw_text,
1326 |     STATE(22), 1,
1327 |       sym_end_tag,
1328 |   [819] = 3,
1329 |     ACTIONS(3), 1,
1330 |       sym_comment,
1331 |     ACTIONS(179), 1,
1332 |       anon_sym_EQ,
1333 |     ACTIONS(122), 2,
1334 |       anon_sym_GT,
1335 |       sym_attribute_name,
1336 |   [830] = 4,
1337 |     ACTIONS(3), 1,
1338 |       sym_comment,
1339 |     ACTIONS(181), 1,
1340 |       anon_sym_LT_SLASH,
1341 |     ACTIONS(183), 1,
1342 |       sym_raw_text,
1343 |     STATE(23), 1,
1344 |       sym_end_tag,
1345 |   [843] = 4,
1346 |     ACTIONS(3), 1,
1347 |       sym_comment,
1348 |     ACTIONS(181), 1,
1349 |       anon_sym_LT_SLASH,
1350 |     ACTIONS(185), 1,
1351 |       sym_raw_text,
1352 |     STATE(21), 1,
1353 |       sym_end_tag,
1354 |   [856] = 4,
1355 |     ACTIONS(3), 1,
1356 |       sym_comment,
1357 |     ACTIONS(165), 1,
1358 |       sym__script_start_tag_name,
1359 |     ACTIONS(167), 1,
1360 |       sym__style_start_tag_name,
1361 |     ACTIONS(187), 1,
1362 |       sym__start_tag_name,
1363 |   [869] = 4,
1364 |     ACTIONS(3), 1,
1365 |       sym_comment,
1366 |     ACTIONS(175), 1,
1367 |       anon_sym_LT_SLASH,
1368 |     ACTIONS(189), 1,
1369 |       sym_raw_text,
1370 |     STATE(24), 1,
1371 |       sym_end_tag,
1372 |   [882] = 3,
1373 |     ACTIONS(3), 1,
1374 |       sym_comment,
1375 |     ACTIONS(191), 1,
1376 |       anon_sym_DQUOTE,
1377 |     ACTIONS(193), 1,
1378 |       aux_sym_quoted_attribute_value_token2,
1379 |   [892] = 3,
1380 |     ACTIONS(3), 1,
1381 |       sym_comment,
1382 |     ACTIONS(181), 1,
1383 |       anon_sym_LT_SLASH,
1384 |     STATE(44), 1,
1385 |       sym_end_tag,
1386 |   [902] = 3,
1387 |     ACTIONS(3), 1,
1388 |       sym_comment,
1389 |     ACTIONS(195), 1,
1390 |       sym__end_tag_name,
1391 |     ACTIONS(197), 1,
1392 |       sym_erroneous_end_tag_name,
1393 |   [912] = 3,
1394 |     ACTIONS(3), 1,
1395 |       sym_comment,
1396 |     ACTIONS(199), 1,
1397 |       anon_sym_DQUOTE,
1398 |     ACTIONS(201), 1,
1399 |       aux_sym_quoted_attribute_value_token2,
1400 |   [922] = 3,
1401 |     ACTIONS(3), 1,
1402 |       sym_comment,
1403 |     ACTIONS(199), 1,
1404 |       anon_sym_SQUOTE,
1405 |     ACTIONS(203), 1,
1406 |       aux_sym_quoted_attribute_value_token1,
1407 |   [932] = 3,
1408 |     ACTIONS(3), 1,
1409 |       sym_comment,
1410 |     ACTIONS(191), 1,
1411 |       anon_sym_SQUOTE,
1412 |     ACTIONS(205), 1,
1413 |       aux_sym_quoted_attribute_value_token1,
1414 |   [942] = 3,
1415 |     ACTIONS(3), 1,
1416 |       sym_comment,
1417 |     ACTIONS(197), 1,
1418 |       sym_erroneous_end_tag_name,
1419 |     ACTIONS(207), 1,
1420 |       sym__end_tag_name,
1421 |   [952] = 2,
1422 |     ACTIONS(3), 1,
1423 |       sym_comment,
1424 |     ACTIONS(209), 2,
1425 |       sym_raw_text,
1426 |       anon_sym_LT_SLASH,
1427 |   [960] = 2,
1428 |     ACTIONS(3), 1,
1429 |       sym_comment,
1430 |     ACTIONS(211), 2,
1431 |       sym_raw_text,
1432 |       anon_sym_LT_SLASH,
1433 |   [968] = 3,
1434 |     ACTIONS(3), 1,
1435 |       sym_comment,
1436 |     ACTIONS(181), 1,
1437 |       anon_sym_LT_SLASH,
1438 |     STATE(41), 1,
1439 |       sym_end_tag,
1440 |   [978] = 2,
1441 |     ACTIONS(3), 1,
1442 |       sym_comment,
1443 |     ACTIONS(161), 2,
1444 |       anon_sym_GT,
1445 |       sym_attribute_name,
1446 |   [986] = 2,
1447 |     ACTIONS(3), 1,
1448 |       sym_comment,
1449 |     ACTIONS(169), 2,
1450 |       anon_sym_GT,
1451 |       sym_attribute_name,
1452 |   [994] = 2,
1453 |     ACTIONS(3), 1,
1454 |       sym_comment,
1455 |     ACTIONS(171), 2,
1456 |       anon_sym_GT,
1457 |       sym_attribute_name,
1458 |   [1002] = 2,
1459 |     ACTIONS(3), 1,
1460 |       sym_comment,
1461 |     ACTIONS(173), 2,
1462 |       anon_sym_GT,
1463 |       sym_attribute_name,
1464 |   [1010] = 2,
1465 |     ACTIONS(3), 1,
1466 |       sym_comment,
1467 |     ACTIONS(213), 2,
1468 |       sym_raw_text,
1469 |       anon_sym_LT_SLASH,
1470 |   [1018] = 2,
1471 |     ACTIONS(3), 1,
1472 |       sym_comment,
1473 |     ACTIONS(215), 2,
1474 |       sym_raw_text,
1475 |       anon_sym_LT_SLASH,
1476 |   [1026] = 3,
1477 |     ACTIONS(3), 1,
1478 |       sym_comment,
1479 |     ACTIONS(175), 1,
1480 |       anon_sym_LT_SLASH,
1481 |     STATE(35), 1,
1482 |       sym_end_tag,
1483 |   [1036] = 3,
1484 |     ACTIONS(3), 1,
1485 |       sym_comment,
1486 |     ACTIONS(175), 1,
1487 |       anon_sym_LT_SLASH,
1488 |     STATE(34), 1,
1489 |       sym_end_tag,
1490 |   [1046] = 2,
1491 |     ACTIONS(3), 1,
1492 |       sym_comment,
1493 |     ACTIONS(217), 1,
1494 |       anon_sym_GT,
1495 |   [1053] = 2,
1496 |     ACTIONS(3), 1,
1497 |       sym_comment,
1498 |     ACTIONS(207), 1,
1499 |       sym__end_tag_name,
1500 |   [1060] = 2,
1501 |     ACTIONS(3), 1,
1502 |       sym_comment,
1503 |     ACTIONS(219), 1,
1504 |       anon_sym_GT,
1505 |   [1067] = 2,
1506 |     ACTIONS(3), 1,
1507 |       sym_comment,
1508 |     ACTIONS(221), 1,
1509 |       anon_sym_SQUOTE,
1510 |   [1074] = 2,
1511 |     ACTIONS(3), 1,
1512 |       sym_comment,
1513 |     ACTIONS(221), 1,
1514 |       anon_sym_DQUOTE,
1515 |   [1081] = 2,
1516 |     ACTIONS(3), 1,
1517 |       sym_comment,
1518 |     ACTIONS(223), 1,
1519 |       anon_sym_GT,
1520 |   [1088] = 2,
1521 |     ACTIONS(3), 1,
1522 |       sym_comment,
1523 |     ACTIONS(225), 1,
1524 |       anon_sym_GT,
1525 |   [1095] = 2,
1526 |     ACTIONS(3), 1,
1527 |       sym_comment,
1528 |     ACTIONS(227), 1,
1529 |       aux_sym_rust_attribute_token1,
1530 |   [1102] = 2,
1531 |     ACTIONS(3), 1,
1532 |       sym_comment,
1533 |     ACTIONS(229), 1,
1534 |       anon_sym_RBRACE,
1535 |   [1109] = 2,
1536 |     ACTIONS(3), 1,
1537 |       sym_comment,
1538 |     ACTIONS(231), 1,
1539 |       anon_sym_RBRACE,
1540 |   [1116] = 2,
1541 |     ACTIONS(3), 1,
1542 |       sym_comment,
1543 |     ACTIONS(233), 1,
1544 |       anon_sym_SQUOTE,
1545 |   [1123] = 2,
1546 |     ACTIONS(3), 1,
1547 |       sym_comment,
1548 |     ACTIONS(233), 1,
1549 |       anon_sym_DQUOTE,
1550 |   [1130] = 2,
1551 |     ACTIONS(3), 1,
1552 |       sym_comment,
1553 |     ACTIONS(235), 1,
1554 |       ts_builtin_sym_end,
1555 |   [1137] = 2,
1556 |     ACTIONS(3), 1,
1557 |       sym_comment,
1558 |     ACTIONS(197), 1,
1559 |       sym_erroneous_end_tag_name,
1560 |   [1144] = 2,
1561 |     ACTIONS(3), 1,
1562 |       sym_comment,
1563 |     ACTIONS(237), 1,
1564 |       sym_erroneous_end_tag_name,
1565 |   [1151] = 2,
1566 |     ACTIONS(3), 1,
1567 |       sym_comment,
1568 |     ACTIONS(195), 1,
1569 |       sym__end_tag_name,
1570 |   [1158] = 2,
1571 |     ACTIONS(3), 1,
1572 |       sym_comment,
1573 |     ACTIONS(239), 1,
1574 |       aux_sym_rust_attribute_token1,
1575 | };
1576 | 
1577 | static const uint32_t ts_small_parse_table_map[] = {
1578 |   [SMALL_STATE(2)] = 0,
1579 |   [SMALL_STATE(3)] = 39,
1580 |   [SMALL_STATE(4)] = 78,
1581 |   [SMALL_STATE(5)] = 117,
1582 |   [SMALL_STATE(6)] = 156,
1583 |   [SMALL_STATE(7)] = 192,
1584 |   [SMALL_STATE(8)] = 228,
1585 |   [SMALL_STATE(9)] = 264,
1586 |   [SMALL_STATE(10)] = 284,
1587 |   [SMALL_STATE(11)] = 304,
1588 |   [SMALL_STATE(12)] = 321,
1589 |   [SMALL_STATE(13)] = 336,
1590 |   [SMALL_STATE(14)] = 353,
1591 |   [SMALL_STATE(15)] = 370,
1592 |   [SMALL_STATE(16)] = 387,
1593 |   [SMALL_STATE(17)] = 401,
1594 |   [SMALL_STATE(18)] = 413,
1595 |   [SMALL_STATE(19)] = 425,
1596 |   [SMALL_STATE(20)] = 439,
1597 |   [SMALL_STATE(21)] = 451,
1598 |   [SMALL_STATE(22)] = 463,
1599 |   [SMALL_STATE(23)] = 475,
1600 |   [SMALL_STATE(24)] = 487,
1601 |   [SMALL_STATE(25)] = 499,
1602 |   [SMALL_STATE(26)] = 511,
1603 |   [SMALL_STATE(27)] = 523,
1604 |   [SMALL_STATE(28)] = 535,
1605 |   [SMALL_STATE(29)] = 547,
1606 |   [SMALL_STATE(30)] = 559,
1607 |   [SMALL_STATE(31)] = 573,
1608 |   [SMALL_STATE(32)] = 585,
1609 |   [SMALL_STATE(33)] = 599,
1610 |   [SMALL_STATE(34)] = 611,
1611 |   [SMALL_STATE(35)] = 623,
1612 |   [SMALL_STATE(36)] = 635,
1613 |   [SMALL_STATE(37)] = 647,
1614 |   [SMALL_STATE(38)] = 659,
1615 |   [SMALL_STATE(39)] = 671,
1616 |   [SMALL_STATE(40)] = 683,
1617 |   [SMALL_STATE(41)] = 695,
1618 |   [SMALL_STATE(42)] = 707,
1619 |   [SMALL_STATE(43)] = 719,
1620 |   [SMALL_STATE(44)] = 733,
1621 |   [SMALL_STATE(45)] = 745,
1622 |   [SMALL_STATE(46)] = 757,
1623 |   [SMALL_STATE(47)] = 766,
1624 |   [SMALL_STATE(48)] = 779,
1625 |   [SMALL_STATE(49)] = 788,
1626 |   [SMALL_STATE(50)] = 797,
1627 |   [SMALL_STATE(51)] = 806,
1628 |   [SMALL_STATE(52)] = 819,
1629 |   [SMALL_STATE(53)] = 830,
1630 |   [SMALL_STATE(54)] = 843,
1631 |   [SMALL_STATE(55)] = 856,
1632 |   [SMALL_STATE(56)] = 869,
1633 |   [SMALL_STATE(57)] = 882,
1634 |   [SMALL_STATE(58)] = 892,
1635 |   [SMALL_STATE(59)] = 902,
1636 |   [SMALL_STATE(60)] = 912,
1637 |   [SMALL_STATE(61)] = 922,
1638 |   [SMALL_STATE(62)] = 932,
1639 |   [SMALL_STATE(63)] = 942,
1640 |   [SMALL_STATE(64)] = 952,
1641 |   [SMALL_STATE(65)] = 960,
1642 |   [SMALL_STATE(66)] = 968,
1643 |   [SMALL_STATE(67)] = 978,
1644 |   [SMALL_STATE(68)] = 986,
1645 |   [SMALL_STATE(69)] = 994,
1646 |   [SMALL_STATE(70)] = 1002,
1647 |   [SMALL_STATE(71)] = 1010,
1648 |   [SMALL_STATE(72)] = 1018,
1649 |   [SMALL_STATE(73)] = 1026,
1650 |   [SMALL_STATE(74)] = 1036,
1651 |   [SMALL_STATE(75)] = 1046,
1652 |   [SMALL_STATE(76)] = 1053,
1653 |   [SMALL_STATE(77)] = 1060,
1654 |   [SMALL_STATE(78)] = 1067,
1655 |   [SMALL_STATE(79)] = 1074,
1656 |   [SMALL_STATE(80)] = 1081,
1657 |   [SMALL_STATE(81)] = 1088,
1658 |   [SMALL_STATE(82)] = 1095,
1659 |   [SMALL_STATE(83)] = 1102,
1660 |   [SMALL_STATE(84)] = 1109,
1661 |   [SMALL_STATE(85)] = 1116,
1662 |   [SMALL_STATE(86)] = 1123,
1663 |   [SMALL_STATE(87)] = 1130,
1664 |   [SMALL_STATE(88)] = 1137,
1665 |   [SMALL_STATE(89)] = 1144,
1666 |   [SMALL_STATE(90)] = 1151,
1667 |   [SMALL_STATE(91)] = 1158,
1668 | };
1669 | 
1670 | static const TSParseActionEntry ts_parse_actions[] = {
1671 |   [0] = {.entry = {.count = 0, .reusable = false}},
1672 |   [1] = {.entry = {.count = 1, .reusable = false}}, RECOVER(),
1673 |   [3] = {.entry = {.count = 1, .reusable = true}}, SHIFT_EXTRA(),
1674 |   [5] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_fragment, 0),
1675 |   [7] = {.entry = {.count = 1, .reusable = false}}, SHIFT(47),
1676 |   [9] = {.entry = {.count = 1, .reusable = true}}, SHIFT(89),
1677 |   [11] = {.entry = {.count = 1, .reusable = true}}, SHIFT(6),
1678 |   [13] = {.entry = {.count = 1, .reusable = false}}, SHIFT(55),
1679 |   [15] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63),
1680 |   [17] = {.entry = {.count = 1, .reusable = true}}, SHIFT(7),
1681 |   [19] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33),
1682 |   [21] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2),
1683 |   [23] = {.entry = {.count = 1, .reusable = true}}, SHIFT(20),
1684 |   [25] = {.entry = {.count = 1, .reusable = true}}, SHIFT(59),
1685 |   [27] = {.entry = {.count = 1, .reusable = true}}, SHIFT(5),
1686 |   [29] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28),
1687 |   [31] = {.entry = {.count = 1, .reusable = true}}, SHIFT(45),
1688 |   [33] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_fragment, 1),
1689 |   [35] = {.entry = {.count = 1, .reusable = true}}, SHIFT(8),
1690 |   [37] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_fragment_repeat1, 2), SHIFT_REPEAT(55),
1691 |   [40] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_fragment_repeat1, 2), SHIFT_REPEAT(88),
1692 |   [43] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_fragment_repeat1, 2), SHIFT_REPEAT(7),
1693 |   [46] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_fragment_repeat1, 2),
1694 |   [48] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_fragment_repeat1, 2), SHIFT_REPEAT(47),
1695 |   [51] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_fragment_repeat1, 2), SHIFT_REPEAT(89),
1696 |   [54] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_fragment_repeat1, 2), SHIFT_REPEAT(8),
1697 |   [57] = {.entry = {.count = 1, .reusable = false}}, SHIFT(46),
1698 |   [59] = {.entry = {.count = 1, .reusable = false}}, SHIFT(82),
1699 |   [61] = {.entry = {.count = 1, .reusable = true}}, SHIFT(62),
1700 |   [63] = {.entry = {.count = 1, .reusable = true}}, SHIFT(57),
1701 |   [65] = {.entry = {.count = 1, .reusable = false}}, SHIFT(67),
1702 |   [67] = {.entry = {.count = 1, .reusable = false}}, SHIFT(91),
1703 |   [69] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61),
1704 |   [71] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60),
1705 |   [73] = {.entry = {.count = 1, .reusable = true}}, SHIFT(25),
1706 |   [75] = {.entry = {.count = 1, .reusable = true}}, SHIFT(26),
1707 |   [77] = {.entry = {.count = 1, .reusable = true}}, SHIFT(27),
1708 |   [79] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_start_tag_repeat1, 2),
1709 |   [81] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_start_tag_repeat1, 2), SHIFT_REPEAT(27),
1710 |   [84] = {.entry = {.count = 1, .reusable = true}}, SHIFT(18),
1711 |   [86] = {.entry = {.count = 1, .reusable = true}}, SHIFT(17),
1712 |   [88] = {.entry = {.count = 1, .reusable = true}}, SHIFT(38),
1713 |   [90] = {.entry = {.count = 1, .reusable = true}}, SHIFT(40),
1714 |   [92] = {.entry = {.count = 1, .reusable = true}}, SHIFT(65),
1715 |   [94] = {.entry = {.count = 1, .reusable = true}}, SHIFT(52),
1716 |   [96] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_start_tag, 4),
1717 |   [98] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_start_tag, 4),
1718 |   [100] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_self_closing_tag, 3),
1719 |   [102] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_self_closing_tag, 3),
1720 |   [104] = {.entry = {.count = 1, .reusable = true}}, SHIFT(72),
1721 |   [106] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_element, 2),
1722 |   [108] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_element, 2),
1723 |   [110] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_style_element, 2),
1724 |   [112] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_style_element, 2),
1725 |   [114] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_script_element, 2),
1726 |   [116] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_script_element, 2),
1727 |   [118] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_start_tag, 3),
1728 |   [120] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_start_tag, 3),
1729 |   [122] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_attribute, 1),
1730 |   [124] = {.entry = {.count = 1, .reusable = true}}, SHIFT(9),
1731 |   [126] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_end_tag, 3),
1732 |   [128] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_end_tag, 3),
1733 |   [130] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64),
1734 |   [132] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_erroneous_end_tag, 3),
1735 |   [134] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_erroneous_end_tag, 3),
1736 |   [136] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_start_tag_repeat1, 2), SHIFT_REPEAT(52),
1737 |   [139] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_element, 3),
1738 |   [141] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_element, 3),
1739 |   [143] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_script_element, 3),
1740 |   [145] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_script_element, 3),
1741 |   [147] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_style_element, 3),
1742 |   [149] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_style_element, 3),
1743 |   [151] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_element, 1),
1744 |   [153] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_element, 1),
1745 |   [155] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_self_closing_tag, 4),
1746 |   [157] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_self_closing_tag, 4),
1747 |   [159] = {.entry = {.count = 1, .reusable = true}}, SHIFT(71),
1748 |   [161] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_attribute, 3),
1749 |   [163] = {.entry = {.count = 1, .reusable = true}}, SHIFT(11),
1750 |   [165] = {.entry = {.count = 1, .reusable = true}}, SHIFT(19),
1751 |   [167] = {.entry = {.count = 1, .reusable = true}}, SHIFT(43),
1752 |   [169] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_quoted_attribute_value, 2),
1753 |   [171] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_rust_attribute, 3),
1754 |   [173] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_quoted_attribute_value, 3),
1755 |   [175] = {.entry = {.count = 1, .reusable = true}}, SHIFT(76),
1756 |   [177] = {.entry = {.count = 1, .reusable = true}}, SHIFT(74),
1757 |   [179] = {.entry = {.count = 1, .reusable = true}}, SHIFT(10),
1758 |   [181] = {.entry = {.count = 1, .reusable = true}}, SHIFT(90),
1759 |   [183] = {.entry = {.count = 1, .reusable = true}}, SHIFT(58),
1760 |   [185] = {.entry = {.count = 1, .reusable = true}}, SHIFT(66),
1761 |   [187] = {.entry = {.count = 1, .reusable = true}}, SHIFT(13),
1762 |   [189] = {.entry = {.count = 1, .reusable = true}}, SHIFT(73),
1763 |   [191] = {.entry = {.count = 1, .reusable = false}}, SHIFT(48),
1764 |   [193] = {.entry = {.count = 1, .reusable = true}}, SHIFT(79),
1765 |   [195] = {.entry = {.count = 1, .reusable = true}}, SHIFT(80),
1766 |   [197] = {.entry = {.count = 1, .reusable = true}}, SHIFT(77),
1767 |   [199] = {.entry = {.count = 1, .reusable = false}}, SHIFT(68),
1768 |   [201] = {.entry = {.count = 1, .reusable = true}}, SHIFT(86),
1769 |   [203] = {.entry = {.count = 1, .reusable = true}}, SHIFT(85),
1770 |   [205] = {.entry = {.count = 1, .reusable = true}}, SHIFT(78),
1771 |   [207] = {.entry = {.count = 1, .reusable = true}}, SHIFT(75),
1772 |   [209] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_style_start_tag, 4),
1773 |   [211] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_script_start_tag, 4),
1774 |   [213] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_style_start_tag, 3),
1775 |   [215] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_script_start_tag, 3),
1776 |   [217] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42),
1777 |   [219] = {.entry = {.count = 1, .reusable = true}}, SHIFT(39),
1778 |   [221] = {.entry = {.count = 1, .reusable = true}}, SHIFT(50),
1779 |   [223] = {.entry = {.count = 1, .reusable = true}}, SHIFT(29),
1780 |   [225] = {.entry = {.count = 1, .reusable = true}}, SHIFT(31),
1781 |   [227] = {.entry = {.count = 1, .reusable = true}}, SHIFT(83),
1782 |   [229] = {.entry = {.count = 1, .reusable = true}}, SHIFT(49),
1783 |   [231] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69),
1784 |   [233] = {.entry = {.count = 1, .reusable = true}}, SHIFT(70),
1785 |   [235] = {.entry = {.count = 1, .reusable = true}},  ACCEPT_INPUT(),
1786 |   [237] = {.entry = {.count = 1, .reusable = true}}, SHIFT(81),
1787 |   [239] = {.entry = {.count = 1, .reusable = true}}, SHIFT(84),
1788 | };
1789 | 
1790 | #ifdef __cplusplus
1791 | extern "C" {
1792 | #endif
1793 | void *tree_sitter_rsx_external_scanner_create(void);
1794 | void tree_sitter_rsx_external_scanner_destroy(void *);
1795 | bool tree_sitter_rsx_external_scanner_scan(void *, TSLexer *, const bool *);
1796 | unsigned tree_sitter_rsx_external_scanner_serialize(void *, char *);
1797 | void tree_sitter_rsx_external_scanner_deserialize(void *, const char *, unsigned);
1798 | 
1799 | #ifdef _WIN32
1800 | #define extern __declspec(dllexport)
1801 | #endif
1802 | 
1803 | extern const TSLanguage *tree_sitter_rsx(void) {
1804 |   static const TSLanguage language = {
1805 |     .version = LANGUAGE_VERSION,
1806 |     .symbol_count = SYMBOL_COUNT,
1807 |     .alias_count = ALIAS_COUNT,
1808 |     .token_count = TOKEN_COUNT,
1809 |     .external_token_count = EXTERNAL_TOKEN_COUNT,
1810 |     .state_count = STATE_COUNT,
1811 |     .large_state_count = LARGE_STATE_COUNT,
1812 |     .production_id_count = PRODUCTION_ID_COUNT,
1813 |     .field_count = FIELD_COUNT,
1814 |     .max_alias_sequence_length = MAX_ALIAS_SEQUENCE_LENGTH,
1815 |     .parse_table = &ts_parse_table[0][0],
1816 |     .small_parse_table = ts_small_parse_table,
1817 |     .small_parse_table_map = ts_small_parse_table_map,
1818 |     .parse_actions = ts_parse_actions,
1819 |     .symbol_names = ts_symbol_names,
1820 |     .symbol_metadata = ts_symbol_metadata,
1821 |     .public_symbol_map = ts_symbol_map,
1822 |     .alias_map = ts_non_terminal_alias_map,
1823 |     .alias_sequences = &ts_alias_sequences[0][0],
1824 |     .lex_modes = ts_lex_modes,
1825 |     .lex_fn = ts_lex,
1826 |     .external_scanner = {
1827 |       &ts_external_scanner_states[0][0],
1828 |       ts_external_scanner_symbol_map,
1829 |       tree_sitter_rsx_external_scanner_create,
1830 |       tree_sitter_rsx_external_scanner_destroy,
1831 |       tree_sitter_rsx_external_scanner_scan,
1832 |       tree_sitter_rsx_external_scanner_serialize,
1833 |       tree_sitter_rsx_external_scanner_deserialize,
1834 |     },
1835 |   };
1836 |   return &language;
1837 | }
1838 | #ifdef __cplusplus
1839 | }
1840 | #endif
1841 | 


--------------------------------------------------------------------------------
/src/scanner.cc:
--------------------------------------------------------------------------------
  1 | #include <tree_sitter/parser.h>
  2 | #include <algorithm>
  3 | #include <vector>
  4 | #include <string>
  5 | #include <cwctype>
  6 | #include <cstring>
  7 | #include "tag.h"
  8 | 
  9 | namespace {
 10 | 
 11 | using std::vector;
 12 | using std::string;
 13 | 
 14 | enum TokenType {
 15 |   START_TAG_NAME,
 16 |   SCRIPT_START_TAG_NAME,
 17 |   STYLE_START_TAG_NAME,
 18 |   END_TAG_NAME,
 19 |   ERRONEOUS_END_TAG_NAME,
 20 |   SELF_CLOSING_TAG_DELIMITER,
 21 |   IMPLICIT_END_TAG,
 22 |   RAW_TEXT,
 23 |   COMMENT
 24 | };
 25 | 
 26 | struct Scanner {
 27 |   Scanner() {}
 28 | 
 29 |   unsigned serialize(char *buffer) {
 30 |     uint16_t tag_count = tags.size() > UINT16_MAX ? UINT16_MAX : tags.size();
 31 |     uint16_t serialized_tag_count = 0;
 32 | 
 33 |     unsigned i = sizeof(tag_count);
 34 |     std::memcpy(&buffer[i], &tag_count, sizeof(tag_count));
 35 |     i += sizeof(tag_count);
 36 | 
 37 |     for (; serialized_tag_count < tag_count; serialized_tag_count++) {
 38 |       Tag &tag = tags[serialized_tag_count];
 39 |       if (tag.type == CUSTOM) {
 40 |         unsigned name_length = tag.custom_tag_name.size();
 41 |         if (name_length > UINT8_MAX) name_length = UINT8_MAX;
 42 |         if (i + 2 + name_length >= TREE_SITTER_SERIALIZATION_BUFFER_SIZE) break;
 43 |         buffer[i++] = static_cast<char>(tag.type);
 44 |         buffer[i++] = name_length;
 45 |         tag.custom_tag_name.copy(&buffer[i], name_length);
 46 |         i += name_length;
 47 |       } else {
 48 |         if (i + 1 >= TREE_SITTER_SERIALIZATION_BUFFER_SIZE) break;
 49 |         buffer[i++] = static_cast<char>(tag.type);
 50 |       }
 51 |     }
 52 | 
 53 |     std::memcpy(&buffer[0], &serialized_tag_count, sizeof(serialized_tag_count));
 54 |     return i;
 55 |   }
 56 | 
 57 |   void deserialize(const char *buffer, unsigned length) {
 58 |     tags.clear();
 59 |     if (length > 0) {
 60 |       unsigned i = 0;
 61 |       uint16_t tag_count, serialized_tag_count;
 62 | 
 63 |       std::memcpy(&serialized_tag_count, &buffer[i], sizeof(serialized_tag_count));
 64 |       i += sizeof(serialized_tag_count);
 65 | 
 66 |       std::memcpy(&tag_count, &buffer[i], sizeof(tag_count));
 67 |       i += sizeof(tag_count);
 68 | 
 69 |       tags.resize(tag_count);
 70 |       for (unsigned j = 0; j < serialized_tag_count; j++) {
 71 |         Tag &tag = tags[j];
 72 |         tag.type = static_cast<TagType>(buffer[i++]);
 73 |         if (tag.type == CUSTOM) {
 74 |           uint16_t name_length = static_cast<uint8_t>(buffer[i++]);
 75 |           tag.custom_tag_name.assign(&buffer[i], &buffer[i + name_length]);
 76 |           i += name_length;
 77 |         }
 78 |       }
 79 |     }
 80 |   }
 81 | 
 82 |   string scan_tag_name(TSLexer *lexer) {
 83 |     string tag_name;
 84 |     while (iswalnum(lexer->lookahead) ||
 85 |            lexer->lookahead == '-' ||
 86 |            lexer->lookahead == ':') {
 87 |       tag_name += towupper(lexer->lookahead);
 88 |       lexer->advance(lexer, false);
 89 |     }
 90 |     return tag_name;
 91 |   }
 92 | 
 93 |   bool scan_comment(TSLexer *lexer) {
 94 |     if (lexer->lookahead != '-') return false;
 95 |     lexer->advance(lexer, false);
 96 |     if (lexer->lookahead != '-') return false;
 97 |     lexer->advance(lexer, false);
 98 | 
 99 |     unsigned dashes = 0;
100 |     while (lexer->lookahead) {
101 |       switch (lexer->lookahead) {
102 |         case '-':
103 |           ++dashes;
104 |           break;
105 |         case '>':
106 |           if (dashes >= 2) {
107 |             lexer->result_symbol = COMMENT;
108 |             lexer->advance(lexer, false);
109 |             lexer->mark_end(lexer);
110 |             return true;
111 |           }
112 |         default:
113 |           dashes = 0;
114 |       }
115 |       lexer->advance(lexer, false);
116 |     }
117 |     return false;
118 |   }
119 | 
120 |   bool scan_raw_text(TSLexer *lexer) {
121 |     if (!tags.size()) return false;
122 | 
123 |     lexer->mark_end(lexer);
124 | 
125 |     const string &end_delimiter = tags.back().type == SCRIPT
126 |       ? "</SCRIPT"
127 |       : "</STYLE";
128 | 
129 |     unsigned delimiter_index = 0;
130 |     while (lexer->lookahead) {
131 |       if (towupper(lexer->lookahead) == end_delimiter[delimiter_index]) {
132 |         delimiter_index++;
133 |         if (delimiter_index == end_delimiter.size()) break;
134 |         lexer->advance(lexer, false);
135 |       } else {
136 |         delimiter_index = 0;
137 |         lexer->advance(lexer, false);
138 |         lexer->mark_end(lexer);
139 |       }
140 |     }
141 | 
142 |     lexer->result_symbol = RAW_TEXT;
143 |     return true;
144 |   }
145 | 
146 |   bool scan_implicit_end_tag(TSLexer *lexer) {
147 |     Tag *parent = tags.empty() ? NULL : &tags.back();
148 | 
149 |     bool is_closing_tag = false;
150 |     if (lexer->lookahead == '/') {
151 |       is_closing_tag = true;
152 |       lexer->advance(lexer, false);
153 |     } else {
154 |       if (parent && parent->is_void()) {
155 |         tags.pop_back();
156 |         lexer->result_symbol = IMPLICIT_END_TAG;
157 |         return true;
158 |       }
159 |     }
160 | 
161 |     string tag_name = scan_tag_name(lexer);
162 |     if (tag_name.empty()) return false;
163 | 
164 |     Tag next_tag = Tag::for_name(tag_name);
165 | 
166 |     if (is_closing_tag) {
167 |       // The tag correctly closes the topmost element on the stack
168 |       if (!tags.empty() && tags.back() == next_tag) return false;
169 | 
170 |       // Otherwise, dig deeper and queue implicit end tags (to be nice in
171 |       // the case of malformed rsx)
172 |       if (std::find(tags.begin(), tags.end(), next_tag) != tags.end()) {
173 |         tags.pop_back();
174 |         lexer->result_symbol = IMPLICIT_END_TAG;
175 |         return true;
176 |       }
177 |     } else if (parent && !parent->can_contain(next_tag)) {
178 |       tags.pop_back();
179 |       lexer->result_symbol = IMPLICIT_END_TAG;
180 |       return true;
181 |     }
182 | 
183 |     return false;
184 |   }
185 | 
186 |   bool scan_start_tag_name(TSLexer *lexer) {
187 |     string tag_name = scan_tag_name(lexer);
188 |     if (tag_name.empty()) return false;
189 |     Tag tag = Tag::for_name(tag_name);
190 |     tags.push_back(tag);
191 |     switch (tag.type) {
192 |       case SCRIPT:
193 |         lexer->result_symbol = SCRIPT_START_TAG_NAME;
194 |         break;
195 |       case STYLE:
196 |         lexer->result_symbol = STYLE_START_TAG_NAME;
197 |         break;
198 |       default:
199 |         lexer->result_symbol = START_TAG_NAME;
200 |         break;
201 |     }
202 |     return true;
203 |   }
204 | 
205 |   bool scan_end_tag_name(TSLexer *lexer) {
206 |     string tag_name = scan_tag_name(lexer);
207 |     if (tag_name.empty()) return false;
208 |     Tag tag = Tag::for_name(tag_name);
209 |     if (!tags.empty() && tags.back() == tag) {
210 |       tags.pop_back();
211 |       lexer->result_symbol = END_TAG_NAME;
212 |     } else {
213 |       lexer->result_symbol = ERRONEOUS_END_TAG_NAME;
214 |     }
215 |     return true;
216 |   }
217 | 
218 |   bool scan_self_closing_tag_delimiter(TSLexer *lexer) {
219 |     lexer->advance(lexer, false);
220 |     if (lexer->lookahead == '>') {
221 |       lexer->advance(lexer, false);
222 |       if (!tags.empty()) {
223 |         tags.pop_back();
224 |         lexer->result_symbol = SELF_CLOSING_TAG_DELIMITER;
225 |       }
226 |       return true;
227 |     }
228 |     return false;
229 |   }
230 | 
231 |   bool scan(TSLexer *lexer, const bool *valid_symbols) {
232 |     while (iswspace(lexer->lookahead)) {
233 |       lexer->advance(lexer, true);
234 |     }
235 | 
236 |     if (valid_symbols[RAW_TEXT] && !valid_symbols[START_TAG_NAME] && !valid_symbols[END_TAG_NAME]) {
237 |       return scan_raw_text(lexer);
238 |     }
239 | 
240 |     switch (lexer->lookahead) {
241 |       case '<':
242 |         lexer->mark_end(lexer);
243 |         lexer->advance(lexer, false);
244 | 
245 |         if (lexer->lookahead == '!') {
246 |           lexer->advance(lexer, false);
247 |           return scan_comment(lexer);
248 |         }
249 | 
250 |         if (valid_symbols[IMPLICIT_END_TAG]) {
251 |           return scan_implicit_end_tag(lexer);
252 |         }
253 |         break;
254 | 
255 |       case '\0':
256 |         if (valid_symbols[IMPLICIT_END_TAG]) {
257 |           return scan_implicit_end_tag(lexer);
258 |         }
259 |         break;
260 | 
261 |       case '/':
262 |         if (valid_symbols[SELF_CLOSING_TAG_DELIMITER]) {
263 |           return scan_self_closing_tag_delimiter(lexer);
264 |         }
265 |         break;
266 | 
267 |       default:
268 |         if ((valid_symbols[START_TAG_NAME] || valid_symbols[END_TAG_NAME]) && !valid_symbols[RAW_TEXT]) {
269 |           return valid_symbols[START_TAG_NAME]
270 |             ? scan_start_tag_name(lexer)
271 |             : scan_end_tag_name(lexer);
272 |         }
273 |     }
274 | 
275 |     return false;
276 |   }
277 | 
278 |   vector<Tag> tags;
279 | };
280 | 
281 | }
282 | 
283 | extern "C" {
284 | 
285 | void *tree_sitter_rsx_external_scanner_create() {
286 |   return new Scanner();
287 | }
288 | 
289 | bool tree_sitter_rsx_external_scanner_scan(void *payload, TSLexer *lexer,
290 |                                             const bool *valid_symbols) {
291 |   Scanner *scanner = static_cast<Scanner *>(payload);
292 |   return scanner->scan(lexer, valid_symbols);
293 | }
294 | 
295 | unsigned tree_sitter_rsx_external_scanner_serialize(void *payload, char *buffer) {
296 |   Scanner *scanner = static_cast<Scanner *>(payload);
297 |   return scanner->serialize(buffer);
298 | }
299 | 
300 | void tree_sitter_rsx_external_scanner_deserialize(void *payload, const char *buffer, unsigned length) {
301 |   Scanner *scanner = static_cast<Scanner *>(payload);
302 |   scanner->deserialize(buffer, length);
303 | }
304 | 
305 | void tree_sitter_rsx_external_scanner_destroy(void *payload) {
306 |   Scanner *scanner = static_cast<Scanner *>(payload);
307 |   delete scanner;
308 | }
309 | 
310 | }
311 | 


--------------------------------------------------------------------------------
/src/tag.h:
--------------------------------------------------------------------------------
  1 | #include <string>
  2 | #include <map>
  3 | 
  4 | using std::string;
  5 | using std::map;
  6 | 
  7 | enum TagType {
  8 |   AREA,
  9 |   BASE,
 10 |   BASEFONT,
 11 |   BGSOUND,
 12 |   BR,
 13 |   COL,
 14 |   COMMAND,
 15 |   EMBED,
 16 |   FRAME,
 17 |   HR,
 18 |   IMAGE,
 19 |   IMG,
 20 |   INPUT,
 21 |   ISINDEX,
 22 |   KEYGEN,
 23 |   LINK,
 24 |   MENUITEM,
 25 |   META,
 26 |   NEXTID,
 27 |   PARAM,
 28 |   SOURCE,
 29 |   TRACK,
 30 |   WBR,
 31 |   END_OF_VOID_TAGS,
 32 | 
 33 |   A,
 34 |   ABBR,
 35 |   ADDRESS,
 36 |   ARTICLE,
 37 |   ASIDE,
 38 |   AUDIO,
 39 |   B,
 40 |   BDI,
 41 |   BDO,
 42 |   BLOCKQUOTE,
 43 |   BODY,
 44 |   BUTTON,
 45 |   CANVAS,
 46 |   CAPTION,
 47 |   CITE,
 48 |   CODE,
 49 |   COLGROUP,
 50 |   DATA,
 51 |   DATALIST,
 52 |   DD,
 53 |   DEL,
 54 |   DETAILS,
 55 |   DFN,
 56 |   DIALOG,
 57 |   DIV,
 58 |   DL,
 59 |   DT,
 60 |   EM,
 61 |   FIELDSET,
 62 |   FIGCAPTION,
 63 |   FIGURE,
 64 |   FOOTER,
 65 |   FORM,
 66 |   H1,
 67 |   H2,
 68 |   H3,
 69 |   H4,
 70 |   H5,
 71 |   H6,
 72 |   HEAD,
 73 |   HEADER,
 74 |   HGROUP,
 75 |   HTML,
 76 |   I,
 77 |   IFRAME,
 78 |   INS,
 79 |   KBD,
 80 |   LABEL,
 81 |   LEGEND,
 82 |   LI,
 83 |   MAIN,
 84 |   MAP,
 85 |   MARK,
 86 |   MATH,
 87 |   MENU,
 88 |   METER,
 89 |   NAV,
 90 |   NOSCRIPT,
 91 |   OBJECT,
 92 |   OL,
 93 |   OPTGROUP,
 94 |   OPTION,
 95 |   OUTPUT,
 96 |   P,
 97 |   PICTURE,
 98 |   PRE,
 99 |   PROGRESS,
100 |   Q,
101 |   RB,
102 |   RP,
103 |   RT,
104 |   RTC,
105 |   RUBY,
106 |   S,
107 |   SAMP,
108 |   SCRIPT,
109 |   SECTION,
110 |   SELECT,
111 |   SLOT,
112 |   SMALL,
113 |   SPAN,
114 |   STRONG,
115 |   STYLE,
116 |   SUB,
117 |   SUMMARY,
118 |   SUP,
119 |   SVG,
120 |   TABLE,
121 |   TBODY,
122 |   TD,
123 |   TEMPLATE,
124 |   TEXTAREA,
125 |   TFOOT,
126 |   TH,
127 |   THEAD,
128 |   TIME,
129 |   TITLE,
130 |   TR,
131 |   U,
132 |   UL,
133 |   VAR,
134 |   VIDEO,
135 | 
136 |   CUSTOM,
137 | };
138 | 
139 | 
140 | static const map<string, TagType> get_tag_map() {
141 |   map<string, TagType> result;
142 | #define TAG(name) result[#name] = name
143 |   TAG(AREA);
144 |   TAG(BASE);
145 |   TAG(BASEFONT);
146 |   TAG(BGSOUND);
147 |   TAG(BR);
148 |   TAG(COL);
149 |   TAG(COMMAND);
150 |   TAG(EMBED);
151 |   TAG(FRAME);
152 |   TAG(HR);
153 |   TAG(IMAGE);
154 |   TAG(IMG);
155 |   TAG(INPUT);
156 |   TAG(ISINDEX);
157 |   TAG(KEYGEN);
158 |   TAG(LINK);
159 |   TAG(MENUITEM);
160 |   TAG(META);
161 |   TAG(NEXTID);
162 |   TAG(PARAM);
163 |   TAG(SOURCE);
164 |   TAG(TRACK);
165 |   TAG(WBR);
166 |   TAG(A);
167 |   TAG(ABBR);
168 |   TAG(ADDRESS);
169 |   TAG(ARTICLE);
170 |   TAG(ASIDE);
171 |   TAG(AUDIO);
172 |   TAG(B);
173 |   TAG(BDI);
174 |   TAG(BDO);
175 |   TAG(BLOCKQUOTE);
176 |   TAG(BODY);
177 |   TAG(BUTTON);
178 |   TAG(CANVAS);
179 |   TAG(CAPTION);
180 |   TAG(CITE);
181 |   TAG(CODE);
182 |   TAG(COLGROUP);
183 |   TAG(DATA);
184 |   TAG(DATALIST);
185 |   TAG(DD);
186 |   TAG(DEL);
187 |   TAG(DETAILS);
188 |   TAG(DFN);
189 |   TAG(DIALOG);
190 |   TAG(DIV);
191 |   TAG(DL);
192 |   TAG(DT);
193 |   TAG(EM);
194 |   TAG(FIELDSET);
195 |   TAG(FIGCAPTION);
196 |   TAG(FIGURE);
197 |   TAG(FOOTER);
198 |   TAG(FORM);
199 |   TAG(H1);
200 |   TAG(H2);
201 |   TAG(H3);
202 |   TAG(H4);
203 |   TAG(H5);
204 |   TAG(H6);
205 |   TAG(HEAD);
206 |   TAG(HEADER);
207 |   TAG(HGROUP);
208 |   TAG(HTML);
209 |   TAG(I);
210 |   TAG(IFRAME);
211 |   TAG(INS);
212 |   TAG(KBD);
213 |   TAG(LABEL);
214 |   TAG(LEGEND);
215 |   TAG(LI);
216 |   TAG(MAIN);
217 |   TAG(MAP);
218 |   TAG(MARK);
219 |   TAG(MATH);
220 |   TAG(MENU);
221 |   TAG(METER);
222 |   TAG(NAV);
223 |   TAG(NOSCRIPT);
224 |   TAG(OBJECT);
225 |   TAG(OL);
226 |   TAG(OPTGROUP);
227 |   TAG(OPTION);
228 |   TAG(OUTPUT);
229 |   TAG(P);
230 |   TAG(PICTURE);
231 |   TAG(PRE);
232 |   TAG(PROGRESS);
233 |   TAG(Q);
234 |   TAG(RB);
235 |   TAG(RP);
236 |   TAG(RT);
237 |   TAG(RTC);
238 |   TAG(RUBY);
239 |   TAG(S);
240 |   TAG(SAMP);
241 |   TAG(SCRIPT);
242 |   TAG(SECTION);
243 |   TAG(SELECT);
244 |   TAG(SLOT);
245 |   TAG(SMALL);
246 |   TAG(SPAN);
247 |   TAG(STRONG);
248 |   TAG(STYLE);
249 |   TAG(SUB);
250 |   TAG(SUMMARY);
251 |   TAG(SUP);
252 |   TAG(SVG);
253 |   TAG(TABLE);
254 |   TAG(TBODY);
255 |   TAG(TD);
256 |   TAG(TEMPLATE);
257 |   TAG(TEXTAREA);
258 |   TAG(TFOOT);
259 |   TAG(TH);
260 |   TAG(THEAD);
261 |   TAG(TIME);
262 |   TAG(TITLE);
263 |   TAG(TR);
264 |   TAG(U);
265 |   TAG(UL);
266 |   TAG(VAR);
267 |   TAG(VIDEO);
268 | #undef TAG
269 |   return result;
270 | }
271 | 
272 | static const map<string, TagType> TAG_TYPES_BY_TAG_NAME = get_tag_map();
273 | 
274 | static const TagType TAG_TYPES_NOT_ALLOWED_IN_PARAGRAPHS[] = {
275 |   ADDRESS,
276 |   ARTICLE,
277 |   ASIDE,
278 |   BLOCKQUOTE,
279 |   DETAILS,
280 |   DIV,
281 |   DL,
282 |   FIELDSET,
283 |   FIGCAPTION,
284 |   FIGURE,
285 |   FOOTER,
286 |   FORM,
287 |   H1,
288 |   H2,
289 |   H3,
290 |   H4,
291 |   H5,
292 |   H6,
293 |   HEADER,
294 |   HR,
295 |   MAIN,
296 |   NAV,
297 |   OL,
298 |   P,
299 |   PRE,
300 |   SECTION,
301 | };
302 | 
303 | static const TagType *TAG_TYPES_NOT_ALLOWED_IN_PARAGRAPHS_END = (
304 |   TAG_TYPES_NOT_ALLOWED_IN_PARAGRAPHS +
305 |   sizeof(TAG_TYPES_NOT_ALLOWED_IN_PARAGRAPHS) /
306 |   sizeof(TagType)
307 | );
308 | 
309 | struct Tag {
310 |   TagType type;
311 |   string custom_tag_name;
312 | 
313 |   // This default constructor is used in the case where there is not enough space
314 |   // in the serialization buffer to store all of the tags. In that case, tags
315 |   // that cannot be serialized will be treated as having an unknown type. These
316 |   // tags will be closed via implicit end tags regardless of the next closing
317 |   // tag is encountered.
318 |   Tag() : type(END_OF_VOID_TAGS) {}
319 | 
320 |   Tag(TagType type, const string &name) : type(type), custom_tag_name(name) {}
321 | 
322 |   bool operator==(const Tag &other) const {
323 |     if (type != other.type) return false;
324 |     if (type == CUSTOM && custom_tag_name != other.custom_tag_name) return false;
325 |     return true;
326 |   }
327 | 
328 |   inline bool is_void() const {
329 |     return type < END_OF_VOID_TAGS;
330 |   }
331 | 
332 |   inline bool can_contain(const Tag &tag) {
333 |     TagType child = tag.type;
334 | 
335 |     switch (type) {
336 |       case LI: return child != LI;
337 | 
338 |       case DT:
339 |       case DD:
340 |         return child != DT && child != DD;
341 | 
342 |       case P:
343 |         return std::find(
344 |           TAG_TYPES_NOT_ALLOWED_IN_PARAGRAPHS,
345 |           TAG_TYPES_NOT_ALLOWED_IN_PARAGRAPHS_END,
346 |           tag.type
347 |         ) == TAG_TYPES_NOT_ALLOWED_IN_PARAGRAPHS_END;
348 | 
349 |       case COLGROUP:
350 |         return child == COL;
351 | 
352 |       case RB:
353 |       case RT:
354 |       case RP:
355 |         return child != RB && child != RT && child != RP;
356 | 
357 |       case OPTGROUP:
358 |         return child != OPTGROUP;
359 | 
360 |       case TR:
361 |         return child != TR;
362 | 
363 |       case TD:
364 |       case TH:
365 |         return child != TD && child != TH && child != TR;
366 | 
367 |       default:
368 |         return true;
369 |     }
370 |   }
371 | 
372 |   static inline Tag for_name(const string &name) {
373 |     map<string, TagType>::const_iterator type = TAG_TYPES_BY_TAG_NAME.find(name);
374 |     if (type != TAG_TYPES_BY_TAG_NAME.end()) {
375 |       return Tag(type->second, string());
376 |     } else {
377 |       return Tag(CUSTOM, name);
378 |     }
379 |   }
380 | };
381 | 


--------------------------------------------------------------------------------
/src/tree_sitter/parser.h:
--------------------------------------------------------------------------------
  1 | #ifndef TREE_SITTER_PARSER_H_
  2 | #define TREE_SITTER_PARSER_H_
  3 | 
  4 | #ifdef __cplusplus
  5 | extern "C" {
  6 | #endif
  7 | 
  8 | #include <stdbool.h>
  9 | #include <stdint.h>
 10 | #include <stdlib.h>
 11 | 
 12 | #define ts_builtin_sym_error ((TSSymbol)-1)
 13 | #define ts_builtin_sym_end 0
 14 | #define TREE_SITTER_SERIALIZATION_BUFFER_SIZE 1024
 15 | 
 16 | typedef uint16_t TSStateId;
 17 | 
 18 | #ifndef TREE_SITTER_API_H_
 19 | typedef uint16_t TSSymbol;
 20 | typedef uint16_t TSFieldId;
 21 | typedef struct TSLanguage TSLanguage;
 22 | #endif
 23 | 
 24 | typedef struct {
 25 |   TSFieldId field_id;
 26 |   uint8_t child_index;
 27 |   bool inherited;
 28 | } TSFieldMapEntry;
 29 | 
 30 | typedef struct {
 31 |   uint16_t index;
 32 |   uint16_t length;
 33 | } TSFieldMapSlice;
 34 | 
 35 | typedef struct {
 36 |   bool visible;
 37 |   bool named;
 38 |   bool supertype;
 39 | } TSSymbolMetadata;
 40 | 
 41 | typedef struct TSLexer TSLexer;
 42 | 
 43 | struct TSLexer {
 44 |   int32_t lookahead;
 45 |   TSSymbol result_symbol;
 46 |   void (*advance)(TSLexer *, bool);
 47 |   void (*mark_end)(TSLexer *);
 48 |   uint32_t (*get_column)(TSLexer *);
 49 |   bool (*is_at_included_range_start)(const TSLexer *);
 50 |   bool (*eof)(const TSLexer *);
 51 | };
 52 | 
 53 | typedef enum {
 54 |   TSParseActionTypeShift,
 55 |   TSParseActionTypeReduce,
 56 |   TSParseActionTypeAccept,
 57 |   TSParseActionTypeRecover,
 58 | } TSParseActionType;
 59 | 
 60 | typedef union {
 61 |   struct {
 62 |     uint8_t type;
 63 |     TSStateId state;
 64 |     bool extra;
 65 |     bool repetition;
 66 |   } shift;
 67 |   struct {
 68 |     uint8_t type;
 69 |     uint8_t child_count;
 70 |     TSSymbol symbol;
 71 |     int16_t dynamic_precedence;
 72 |     uint16_t production_id;
 73 |   } reduce;
 74 |   uint8_t type;
 75 | } TSParseAction;
 76 | 
 77 | typedef struct {
 78 |   uint16_t lex_state;
 79 |   uint16_t external_lex_state;
 80 | } TSLexMode;
 81 | 
 82 | typedef union {
 83 |   TSParseAction action;
 84 |   struct {
 85 |     uint8_t count;
 86 |     bool reusable;
 87 |   } entry;
 88 | } TSParseActionEntry;
 89 | 
 90 | struct TSLanguage {
 91 |   uint32_t version;
 92 |   uint32_t symbol_count;
 93 |   uint32_t alias_count;
 94 |   uint32_t token_count;
 95 |   uint32_t external_token_count;
 96 |   uint32_t state_count;
 97 |   uint32_t large_state_count;
 98 |   uint32_t production_id_count;
 99 |   uint32_t field_count;
100 |   uint16_t max_alias_sequence_length;
101 |   const uint16_t *parse_table;
102 |   const uint16_t *small_parse_table;
103 |   const uint32_t *small_parse_table_map;
104 |   const TSParseActionEntry *parse_actions;
105 |   const char * const *symbol_names;
106 |   const char * const *field_names;
107 |   const TSFieldMapSlice *field_map_slices;
108 |   const TSFieldMapEntry *field_map_entries;
109 |   const TSSymbolMetadata *symbol_metadata;
110 |   const TSSymbol *public_symbol_map;
111 |   const uint16_t *alias_map;
112 |   const TSSymbol *alias_sequences;
113 |   const TSLexMode *lex_modes;
114 |   bool (*lex_fn)(TSLexer *, TSStateId);
115 |   bool (*keyword_lex_fn)(TSLexer *, TSStateId);
116 |   TSSymbol keyword_capture_token;
117 |   struct {
118 |     const bool *states;
119 |     const TSSymbol *symbol_map;
120 |     void *(*create)(void);
121 |     void (*destroy)(void *);
122 |     bool (*scan)(void *, TSLexer *, const bool *symbol_whitelist);
123 |     unsigned (*serialize)(void *, char *);
124 |     void (*deserialize)(void *, const char *, unsigned);
125 |   } external_scanner;
126 |   const TSStateId *primary_state_ids;
127 | };
128 | 
129 | /*
130 |  *  Lexer Macros
131 |  */
132 | 
133 | #define START_LEXER()           \
134 |   bool result = false;          \
135 |   bool skip = false;            \
136 |   bool eof = false;             \
137 |   int32_t lookahead;            \
138 |   goto start;                   \
139 |   next_state:                   \
140 |   lexer->advance(lexer, skip);  \
141 |   start:                        \
142 |   skip = false;                 \
143 |   lookahead = lexer->lookahead;
144 | 
145 | #define ADVANCE(state_value) \
146 |   {                          \
147 |     state = state_value;     \
148 |     goto next_state;         \
149 |   }
150 | 
151 | #define SKIP(state_value) \
152 |   {                       \
153 |     skip = true;          \
154 |     state = state_value;  \
155 |     goto next_state;      \
156 |   }
157 | 
158 | #define ACCEPT_TOKEN(symbol_value)     \
159 |   result = true;                       \
160 |   lexer->result_symbol = symbol_value; \
161 |   lexer->mark_end(lexer);
162 | 
163 | #define END_STATE() return result;
164 | 
165 | /*
166 |  *  Parse Table Macros
167 |  */
168 | 
169 | #define SMALL_STATE(id) id - LARGE_STATE_COUNT
170 | 
171 | #define STATE(id) id
172 | 
173 | #define ACTIONS(id) id
174 | 
175 | #define SHIFT(state_value)            \
176 |   {{                                  \
177 |     .shift = {                        \
178 |       .type = TSParseActionTypeShift, \
179 |       .state = state_value            \
180 |     }                                 \
181 |   }}
182 | 
183 | #define SHIFT_REPEAT(state_value)     \
184 |   {{                                  \
185 |     .shift = {                        \
186 |       .type = TSParseActionTypeShift, \
187 |       .state = state_value,           \
188 |       .repetition = true              \
189 |     }                                 \
190 |   }}
191 | 
192 | #define SHIFT_EXTRA()                 \
193 |   {{                                  \
194 |     .shift = {                        \
195 |       .type = TSParseActionTypeShift, \
196 |       .extra = true                   \
197 |     }                                 \
198 |   }}
199 | 
200 | #define REDUCE(symbol_val, child_count_val, ...) \
201 |   {{                                             \
202 |     .reduce = {                                  \
203 |       .type = TSParseActionTypeReduce,           \
204 |       .symbol = symbol_val,                      \
205 |       .child_count = child_count_val,            \
206 |       __VA_ARGS__                                \
207 |     },                                           \
208 |   }}
209 | 
210 | #define RECOVER()                    \
211 |   {{                                 \
212 |     .type = TSParseActionTypeRecover \
213 |   }}
214 | 
215 | #define ACCEPT_INPUT()              \
216 |   {{                                \
217 |     .type = TSParseActionTypeAccept \
218 |   }}
219 | 
220 | #ifdef __cplusplus
221 | }
222 | #endif
223 | 
224 | #endif  // TREE_SITTER_PARSER_H_
225 | 


--------------------------------------------------------------------------------
/test/corpus/example.txt:
--------------------------------------------------------------------------------
 1 | =============
 2 | Does something
 3 | =============
 4 | 
 5 | <div>
 6 |     <div>
 7 |     </div>
 8 | </div>
 9 | 
10 | ----
11 | 
12 | (fragment
13 |  (element
14 |   (start_tag
15 |    (tag_name))
16 |   (element
17 |    (start_tag
18 |     (tag_name))
19 |    (end_tag
20 |     (tag_name)))
21 |   (end_tag
22 |    (tag_name))))
23 | 
24 | =============
25 | RAW strings
26 | =============
27 | 
28 | <div class="hello-world">
29 |     <div>
30 |     </div>
31 | </div>
32 | 
33 | ----
34 | 
35 | (fragment
36 |  (element
37 |   (start_tag
38 |    (tag_name)
39 |    (attribute
40 |     (attribute_name)
41 |     (quoted_attribute_value
42 |      (attribute_value))))
43 |   (element
44 |    (start_tag
45 |     (tag_name))
46 |    (end_tag
47 |     (tag_name)))
48 |   (end_tag
49 |    (tag_name))))
50 | 
51 | 
52 | =============
53 | Rust strings
54 | =============
55 | 
56 | <div class={ "hello-world" }>
57 |     <div>
58 |         {
59 |             let x = 10;
60 | 
61 |             for history.current().iter().rev().take(20).map(|message| {
62 |                 render_message(message)
63 |             })
64 |         }
65 |     </div>
66 | </div>
67 | 
68 | ----
69 | 
70 | (fragment
71 |  (element
72 |   (start_tag
73 |    (tag_name)
74 |    (attribute
75 |     (attribute_name)
76 |     (rust_attribute)))
77 |   (element
78 |    (start_tag
79 |     (tag_name))
80 |    (rust_text)
81 |    (end_tag
82 |     (tag_name)))
83 |   (end_tag
84 |    (tag_name))))
85 | 


--------------------------------------------------------------------------------