diff --git a/.gitignore b/.gitignore index 7ba6ef7..778c74b 100644 --- a/.gitignore +++ b/.gitignore @@ -2,5 +2,11 @@ node_modules/ build/ *.wasm -# tree-sitter-cli scratch +# tree-sitter-cli scratch and parser-clone caches. +# tree-sitter-cli creates `grammars//` ( underscore form, +# matching the C identifier ) when it auto-clones a grammar repo for +# parser binary caching. Our hand-maintained dirs use hyphens, so the +# underscore variants are always cache. .tree-sitter/ +grammars/p8_cart/ +grammars/pico8_lua/ diff --git a/README.md b/README.md index dd2cd8b..25fff5d 100644 --- a/README.md +++ b/README.md @@ -1,146 +1,186 @@ # zed-p8 A Zed extension for the [PICO-8](https://www.lexaloffle.com/pico-8.php) fantasy -console. The goal is reasonable editor support for the entire `.p8` cartridge -file format and for PICO-8's Lua dialect — even where PICO-8 deviates from +console. Reasonable editor support for the entire `.p8` cartridge file format +and for PICO-8's Lua dialect — including the parts where PICO-8 deviates from standard Lua 5.2 (compound assignments, `?` print shorthand, single-line -`if (cond) ...`, `!=`, binary literals, peek operators, and so on). +`if (cond) ...`, `!=`, `0b...` binary literals, integer divide `\`, peek +operators `@`/`%`/`$`, the rotate/logical-shift family `<<>` / `>><` / `>>>`, +and `#include`). -## Status — v0.1 scaffold +## Status — v0.2 Working today: -- A small tree-sitter grammar (`p8_cart`, in this repo's root) that parses - the `.p8` cartridge container: the magic header line, `version` line, and - the named sections `__lua__`, `__gfx__`, `__gff__`, `__label__`, `__map__`, - `__sfx__`, `__music__`. Unknown `__name__` markers are accepted as a - fallback `unknown_section`. -- A Zed language definition `Pico-8 Cartridge` (file suffix `.p8`) that uses - this grammar for outline, section-marker highlighting, and an outline view. -- An injection that hands the body of the `__lua__` section to Zed's - built-in Lua language for syntax highlighting. +- **`tree-sitter-p8-cart`** ( `grammars/p8-cart/` ) — parses the `.p8` + cartridge container: the magic header line, `version` line, and the named + sections `__lua__`, `__gfx__`, `__gff__`, `__label__`, `__map__`, `__sfx__`, + `__music__`. Unknown `__name__` markers fall through to `unknown_section`. +- **`tree-sitter-pico8-lua`** ( `grammars/pico-8-lua/` ) — fork of + [`tree-sitter-grammars/tree-sitter-lua`](https://github.com/tree-sitter-grammars/tree-sitter-lua) + with the PICO-8 dialect added. Handles every dialect form the manual + documents: see *Dialect coverage* below. Upstream attribution is preserved + in `grammars/pico-8-lua/UPSTREAM-LICENSE.md`. +- **`Pico-8 Cartridge`** language ( `languages/pico-8-cart/`, suffix `.p8` ) — + config, marker highlights, outline view, and an injection that hands the + `__lua__` body to the Pico-8 Lua grammar. +- **`Pico-8 Lua`** language ( `languages/pico-8-lua/`, suffix `.p8lua` ) — + config, dialect-aware highlights with PICO-8 builtins recognized, brackets, + indents, outline. -Known limitations: +The `.p8lua` suffix is the convention for bare Pico-8 Lua source files — the +ones pulled into a cart via `#include`. Plain `.lua` files are intentionally +*not* claimed by this extension, so users who keep stock Lua files alongside +their PICO-8 work continue to get standard Lua treatment. + +### Dialect coverage + +| Feature | Status | +|---|---| +| `!=` ( alias for `~=` ) | ✓ | +| Compound assignment: `+= -= *= /= %= \= ^= ..= &= \|= ^^= <<= >>= >>>= <<>= >><=` | ✓ | +| Integer divide `\` and modulo `%` ( binary ) | ✓ | +| Bitwise XOR `^^` ( binary, in addition to upstream's `~` ) | ✓ | +| Logical shift right `>>>`, rotate left `<<>`, rotate right `>><` | ✓ | +| Hex literals with fractional part: `0x11.4000` | ✓ | +| Binary literals: `0b1010` | ✓ | +| Memory peek prefix unary: `@addr`, `%addr`, `$addr` | ✓ | +| Single-line `if (cond) stmt [else stmt]` ( no `then`/`end` ) | ✓ | +| Single-line `while (cond) stmt` ( no `do`/`end` ) | ✓ | +| `?` print shorthand statement | ✓ | +| `#include path` directive | ✓ | +| `_init` / `_update` / `_update60` / `_draw` highlighted as builtins | ✓ | + +### Known limitations -- **PICO-8 Lua dialect is not fully parsed.** The injected grammar is plain - Lua 5.2, which does not understand `?` (print shorthand), `+=` and friends, - `!=`, `0b...` literals, the `\` integer-divide operator, the `@`/`%`/`$` - peek prefixes, or the single-line `if (cond) stmt` / `while (cond) stmt` - forms. Code that uses any of those will show parse-error highlighting in - those regions only — surrounding code remains correctly highlighted. See - Roadmap below. - **No language server.** No completion, hover docs, or diagnostics for - PICO-8 builtins yet. See Roadmap. -- **No `.p8.png` support.** Only the plain-text `.p8` format is handled. + PICO-8 builtins yet — only a static `function.builtin` highlight on + recognized names. See Roadmap. +- **No `.p8.png` support.** Only the plain-text `.p8` format is handled — + the PNG-steganography variant is out of scope for a text-focused IDE + extension. +- **Hex sections are unhighlighted blobs.** `__gfx__`, `__map__`, `__sfx__`, + `__gff__`, `__music__`, `__label__` parse as opaque line bodies. Roadmap + v0.4 covers per-section highlighters. ## Repository layout ``` zed-p8/ - extension.toml ← Zed extension manifest - grammar.js ← tree-sitter-p8-cart grammar source - src/ ← generated parser ( committed; regenerate after grammar.js edits ) - package.json ← tree-sitter-cli devDependency - tree-sitter.json ← tree-sitter-cli config ( auto-managed ) + extension.toml ← Zed extension manifest + package.json ← workspace root; hosts tree-sitter-cli + grammars/ + p8-cart/ ← cart-format tree-sitter grammar + grammar.js + tree-sitter.json + src/ ← generated parser ( committed ) + pico-8-lua/ ← Pico-8 Lua dialect tree-sitter grammar + grammar.js + tree-sitter.json + package.json ← marks this dir as ESM for node + src/ ← generated parser + scanner.c ( committed ) + UPSTREAM-LICENSE.md ← MIT, tree-sitter-lua by Munif Tanjim languages/ - pico-8-cart/ ← Pico-8 Cartridge language files + pico-8-cart/ ← Pico-8 Cartridge language files config.toml highlights.scm + injections.scm ← injects pico-8-lua into __lua__ body + outline.scm + pico-8-lua/ ← Pico-8 Lua language files + config.toml + highlights.scm + brackets.scm + indents.scm injections.scm outline.scm examples/ - hello.p8 ← minimal test cart - references/ ← upstream PICO-8 manual + Zed docs links + hello.p8 ← minimal test cart + references/ ← upstream PICO-8 manual + Zed doc links ``` -The cart grammar lives at the repo root rather than as a separate sibling -repository. This keeps everything in one place during early development; if -the grammar grows or wants to be reused outside Zed it can be split out -later — the only file that needs to move with it is `grammar.js` plus the -generated `src/`, and the `[grammars.p8_cart]` URL in `extension.toml` would -need updating. +Both grammars live in subdirectories of this same repository. Zed's +`[grammars.*]` block supports a `path` field, so the extension manifest +points each grammar at this repo's git URL plus the relevant subdir. ## Local development -Prerequisites: Node.js (for `tree-sitter-cli`) and Zed. Rust is NOT required -unless/until we add a language-server harness. +Prerequisites: Node.js ( for `tree-sitter-cli` ) and Zed. Rust is *not* +required unless / until we add a language-server harness ( v0.3 ). -### Edit-and-reload loop +```sh +npm install # one-time, installs tree-sitter-cli +``` -1. Edit `grammar.js`. -2. Regenerate the parser: +### Edit a grammar and reload + +1. Edit `grammars//grammar.js`. +2. Regenerate from the grammar's directory: ```sh - npx tree-sitter generate + ( cd grammars/p8-cart && npx tree-sitter generate ) + # or + ( cd grammars/pico-8-lua && npx tree-sitter generate ) ``` -3. Sanity-check on a real cart: +3. Sanity-check by parsing a sample file: ```sh - npx tree-sitter parse examples/hello.p8 + ( cd grammars/p8-cart && npx tree-sitter parse ../../examples/hello.p8 ) + ( cd grammars/pico-8-lua && npx tree-sitter parse path/to/file.p8lua ) ``` -4. Commit. The `[grammars.p8_cart]` block in `extension.toml` references this - repo by `file://` URL and pins a commit SHA — Zed clones the grammar - from that pinned revision, so changes only take effect after they're - committed. +4. Commit the regenerated `src/parser.c` along with the grammar change. + Zed clones the grammar repo at the SHA in `extension.toml`, so changes + only take effect after a commit. -5. Update `extension.toml`'s `rev` field to the new SHA, then in Zed run - `zed: install dev extension` (or click *Install Dev Extension* on the - Extensions page) and select this directory. Reinstall after every commit - that should be picked up. +5. Update the `rev` field of the affected `[grammars.*]` block(s) in + `extension.toml` to the new SHA, then in Zed run `zed: install dev + extension` ( or *Install Dev Extension* on the Extensions page ) and + select this directory. Reinstall after every commit that should be + picked up. Logs: `zed: open log`. Run `zed --foreground` for live stdout. -### Editing language queries +### Edit only language queries -Files under `languages/pico-8-cart/` (`highlights.scm`, `injections.scm`, -`outline.scm`) are loaded directly by Zed — no regeneration needed. Reinstall -the dev extension to pick up changes. +Files under `languages/*/` ( `highlights.scm`, `injections.scm`, etc. ) +are loaded directly by Zed — no regeneration step needed. Reinstall the +dev extension to pick up changes. + +### Tests + +Sample carts live under `examples/`. Use `tree-sitter parse` directly for +verification — corpus-style `tree-sitter test` is not currently set up +because the cart grammar's strict `extras: []` doesn't tolerate the +leading newline that the test harness prepends to each fixture. ## Roadmap -### v0.2 — PICO-8 Lua dialect grammar - -Fork [`tree-sitter-grammars/tree-sitter-lua`](https://github.com/tree-sitter-grammars/tree-sitter-lua) -into `tree-sitter-pico8` and add the dialect extensions documented in the -PICO-8 manual: - -- Compound-assignment operators: `+= -= *= /= \= %= ^= ..= &= |= ^^= <<= >>= >>>= <<>= >><=` -- `!=` as alias for `~=` -- `\` (integer divide) and the rotate / logical-shift operators `<<>` `>><` `>>>` -- Binary literals `0b...` and hex fractional literals `0x1.4p0` style -- Single-line `if (cond) stmt` and `while (cond) stmt` ( no `then`/`do`/`end` ) -- `?` as a statement-level shorthand for `print` -- The peek-prefix unary operators `@addr` `%addr` `$addr` - -Then add a second language `Pico-8 Lua` here (separate from Zed's built-in -`Lua`) and switch `injections.scm` to inject `pico-8-lua` instead of `lua`. - ### v0.3 — Language server integration -Wire up [`japhib/pico8-ls`](https://github.com/japhib/pico8-ls) (or whichever -PICO-8 LSP is most maintained at the time) for: +Wire up [`japhib/pico8-ls`](https://github.com/japhib/pico8-ls) ( or whichever +PICO-8 LSP is most maintained at the time ) for: -- Completion of PICO-8 builtins (`spr`, `circfill`, `btn`, `flr`, …) -- Signature help and hover docs sourced from the manual -- Cart-aware analysis ( the LSP already understands `.p8` section markers - and only analyzes the `__lua__` body ) -- Per-cart diagnostics +- Completion of PICO-8 builtins ( `spr`, `circfill`, `btn`, `flr`, … ). +- Signature help and hover docs sourced from the manual. +- Cart-aware analysis — the LSP already understands `.p8` section markers + and only analyzes the `__lua__` body. +- Per-cart diagnostics. -This will require a Rust component ( the `zed_extension_api` crate ) to -download the language-server binary and define -`language_server_command` — see [Zed's developing-extensions docs](https://zed.dev/docs/extensions/developing-extensions). +This requires a Rust component ( the `zed_extension_api` crate ) that +downloads the LSP binary and defines `language_server_command`. +See [Zed's developing-extensions docs](https://zed.dev/docs/extensions/developing-extensions). ### v0.4 — Polish - LuaCATS / EmmyLua stub file enumerating PICO-8's ~110 globals, for users who'd rather wire up `lua-language-server` against their `#include`-d - `.lua` files. -- Highlight rules for hex sections (`__gfx__`, `__map__`, `__sfx__`, etc.) - so palette indices and note pitches show up distinctly. -- Snippets for common idioms (`for x=0,127 do ... end`, the `_init`/`_update`/ - `_draw` triad). + `.p8lua` files. +- Per-section highlighters for the hex blocks: `__gfx__` colored by palette + index, `__sfx__` / `__music__` parsed as note streams, `__map__` as tile + indices, `__gff__` as flag bytes. +- Snippets for common idioms ( the `_init` / `_update` / `_draw` triad, + `for x=0,127 do … end`, palette swap setup, etc. ). ## References @@ -148,7 +188,12 @@ download the language-server binary and define - Zed extension docs: see links in `references/zed-doc-links.md` - Cart file-format spec ( community wiki, not in the official manual ): https://pico-8.fandom.com/wiki/P8FileFormat +- Upstream Lua grammar: https://github.com/tree-sitter-grammars/tree-sitter-lua + ( MIT, by Munif Tanjim — preserved in `grammars/pico-8-lua/UPSTREAM-LICENSE.md` ) ## License -0BSD — see `LICENSE`. +The cart grammar and the Zed extension files are 0BSD ( see `LICENSE` ). +The PICO-8 Lua grammar is a fork of MIT-licensed `tree-sitter-lua`; the +upstream license is preserved at `grammars/pico-8-lua/UPSTREAM-LICENSE.md` +and applies to the derived files in that directory. diff --git a/examples/hello.p8 b/examples/hello.p8 index 6887178..8fc5763 100644 --- a/examples/hello.p8 +++ b/examples/hello.p8 @@ -1,14 +1,24 @@ pico-8 cartridge // http://www.pico-8.com version 42 __lua__ --- hello cartridge +-- hello cartridge — exercises Pico-8 dialect features +#include shared.p8lua + function _init() cls() + t = 0 +end + +function _update() + t += 1 + if (btn(4)) sweep_palette() + move() end function _draw() cls(1) - print("hello pico-8", 30, 60, 7) + draw_blob() + ?"frame:"..t, 0, 120, 7 end __gfx__ 00000000111111110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 diff --git a/examples/shared.p8lua b/examples/shared.p8lua new file mode 100644 index 0000000..b2120b2 --- /dev/null +++ b/examples/shared.p8lua @@ -0,0 +1,30 @@ +-- shared.p8lua: included into hello.p8 via #include +-- demonstrates Pico-8 dialect features outside a __lua__ section. + +local x, y = 64, 64 + +function move() + if (btn(0)) x-=1 + if (btn(1)) x+=1 + if (btn(2)) y-=1 + if (btn(3)) y+=1 + x = mid(0, x, 127) + y = mid(0, y, 127) +end + +function draw_blob() + cls(1) + circfill(x, y, 5, 7) + ?"x="..x..",y="..y, 0, 0, 7 +end + +-- peek/poke via prefix shorthands +function sweep_palette() + for i=0,15 do + poke(0x5f10+i, %0x5f10 ^^ i) + end +end + +-- single-line while with compound assignment body +local i = 0 +while (i < 8) i += 1 diff --git a/extension.toml b/extension.toml index 8bd280d..f2af61a 100644 --- a/extension.toml +++ b/extension.toml @@ -1,15 +1,25 @@ id = "pico-8" name = "Pico-8" -version = "0.0.1" +version = "0.0.2" schema_version = 1 authors = ["Kistaro Windrider "] description = "Pico-8 cartridge (.p8) and Lua dialect support for Zed" repository = "https://github.com/kistaro/zed-p8" -# The .p8 cart container grammar lives at the root of this repo. -# During local development, set `repository` to `file://` + the absolute -# path of your clone and pin `rev` to a committed SHA. When publishing, -# this should point at a public Git URL. +# Both grammars live in this same repository, in subdirectories under +# `grammars/`. Zed's [grammars.*] block supports a `path` field for +# exactly this layout. During local development, `repository` is a +# `file://` URL pointing at this clone and `rev` is pinned to a +# committed SHA — Zed clones the grammar at that revision rather than +# reading the working tree, so changes only take effect after a commit +# + a `rev` bump in this file. + [grammars.p8_cart] repository = "file:///Users/norberg/gitea-repos/zed-p8" -rev = "3f209efa897558e8ecd7aa3612846dc12798b0bb" +rev = "REPLACE_AT_NEXT_COMMIT" +path = "grammars/p8-cart" + +[grammars.pico8_lua] +repository = "file:///Users/norberg/gitea-repos/zed-p8" +rev = "REPLACE_AT_NEXT_COMMIT" +path = "grammars/pico-8-lua" diff --git a/grammar.js b/grammars/p8-cart/grammar.js similarity index 100% rename from grammar.js rename to grammars/p8-cart/grammar.js diff --git a/src/grammar.json b/grammars/p8-cart/src/grammar.json similarity index 100% rename from src/grammar.json rename to grammars/p8-cart/src/grammar.json diff --git a/src/node-types.json b/grammars/p8-cart/src/node-types.json similarity index 100% rename from src/node-types.json rename to grammars/p8-cart/src/node-types.json diff --git a/src/parser.c b/grammars/p8-cart/src/parser.c similarity index 100% rename from src/parser.c rename to grammars/p8-cart/src/parser.c diff --git a/src/tree_sitter/alloc.h b/grammars/p8-cart/src/tree_sitter/alloc.h similarity index 100% rename from src/tree_sitter/alloc.h rename to grammars/p8-cart/src/tree_sitter/alloc.h diff --git a/src/tree_sitter/array.h b/grammars/p8-cart/src/tree_sitter/array.h similarity index 100% rename from src/tree_sitter/array.h rename to grammars/p8-cart/src/tree_sitter/array.h diff --git a/src/tree_sitter/parser.h b/grammars/p8-cart/src/tree_sitter/parser.h similarity index 100% rename from src/tree_sitter/parser.h rename to grammars/p8-cart/src/tree_sitter/parser.h diff --git a/tree-sitter.json b/grammars/p8-cart/tree-sitter.json similarity index 100% rename from tree-sitter.json rename to grammars/p8-cart/tree-sitter.json diff --git a/grammars/pico-8-lua/UPSTREAM-LICENSE.md b/grammars/pico-8-lua/UPSTREAM-LICENSE.md new file mode 100644 index 0000000..ff0407e --- /dev/null +++ b/grammars/pico-8-lua/UPSTREAM-LICENSE.md @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2021 Munif Tanjim + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/grammars/pico-8-lua/grammar.js b/grammars/pico-8-lua/grammar.js new file mode 100644 index 0000000..b341ce4 --- /dev/null +++ b/grammars/pico-8-lua/grammar.js @@ -0,0 +1,598 @@ +/** + * @file PICO-8 Lua grammar for tree-sitter + * + * Forked from tree-sitter-lua 0.5.0 by Munif Tanjim ( MIT — see + * UPSTREAM-LICENSE.md ). This fork adds the PICO-8 dialect extensions + * documented in the PICO-8 manual: + * + * - != as alias for ~= + * - Integer divide: \ + * - Bitwise XOR (binary): ^^ + * - Logical shift right: >>> + * - Rotate left: <<> + * - Rotate right: >>< + * - Compound-assignment statements: += -= *= /= %= \= ^= ..= &= |= ^^= + * <<= >>= >>>= <<>= >><= + * - Memory peek prefix unary operators: @addr %addr $addr + * ( these coexist with binary % for modulo ) + * - Single-line if (cond) stmt [else stmt] — no `then`/`end` + * - Single-line while (cond) stmt — no `do`/`end` + * - Statement-level print shorthand: `?` followed by an expression list + * - `#include path` directive + */ + +/// +// @ts-check + +const PREC = { + OR: 1, // or + AND: 2, // and + COMPARE: 3, // < > <= >= ~= == != + BIT_OR: 4, // | + BIT_NOT: 5, // ~ ^^ + BIT_AND: 6, // & + BIT_SHIFT: 7, // << >> >>> <<> >>< + CONCAT: 8, // .. + PLUS: 9, // + - + MULTI: 10, // * / // % \ + UNARY: 11, // not # - ~ @ $ % + POWER: 12, // ^ +}; + +const list_seq = (rule, separator, trailing_separator = false) => + trailing_separator + ? seq(rule, repeat(seq(separator, rule)), optional(separator)) + : seq(rule, repeat(seq(separator, rule))); + +const optional_block = ($) => alias(optional($._block), $.block); + +// namelist ::= Name {',' Name} +const name_list = ($) => list_seq(field('name', $.identifier), ','); + +const COMPOUND_ASSIGN_OPERATORS = [ + '+=', '-=', '*=', '/=', '%=', '\\=', '^=', '..=', + '&=', '|=', '^^=', + '<<=', '>>=', '>>>=', '<<>=', '>><=', +]; + +export default grammar({ + name: 'pico8_lua', + + extras: ($) => [$.comment, /\s/], + + externals: ($) => [ + $._block_comment_start, + $._block_comment_content, + $._block_comment_end, + + $._block_string_start, + $._block_string_content, + $._block_string_end, + ], + + supertypes: ($) => [$.statement, $.expression, $.declaration, $.variable], + + word: ($) => $.identifier, + + // `if (cond) ...` is ambiguous between a standard if where the condition + // is a parenthesized_expression and a shorthand if. Same for while. The + // ambiguity resolves by what follows the closing `)` ( `then`/`do` for + // the standard form, anything else for the shorthand ). + conflicts: ($) => [ + [$.parenthesized_expression, $.shorthand_if_statement], + [$.parenthesized_expression, $.shorthand_while_statement], + ], + + rules: { + // chunk ::= block + chunk: ($) => + seq( + optional($.hash_bang_line), + repeat($.statement), + optional($.return_statement) + ), + + hash_bang_line: (_) => /#![^\n]*/, + + // block ::= {stat} [retstat] + _block: ($) => + choice( + seq(repeat1($.statement), optional($.return_statement)), + seq(repeat($.statement), $.return_statement) + ), + + statement: ($) => + choice( + $.empty_statement, + $.assignment_statement, + $.compound_assignment_statement, + $.function_call, + $.label_statement, + $.break_statement, + $.goto_statement, + $.do_statement, + $.while_statement, + $.shorthand_while_statement, + $.repeat_statement, + $.if_statement, + $.shorthand_if_statement, + $.for_statement, + $.declaration, + $.print_shorthand_statement, + $.include_statement, + ), + + // retstat ::= return [explist] [';'] + return_statement: ($) => + seq( + 'return', + optional(alias($._expression_list, $.expression_list)), + optional(';') + ), + + empty_statement: (_) => ';', + + assignment_statement: ($) => + seq( + alias($._variable_assignment_varlist, $.variable_list), + field('operator', '='), + alias($._variable_assignment_explist, $.expression_list) + ), + _variable_assignment_varlist: ($) => + list_seq(field('name', $.variable), ','), + _variable_assignment_explist: ($) => + list_seq(field('value', $.expression), ','), + + // PICO-8 compound assignment: var OP= expr (single statement, single line). + compound_assignment_statement: ($) => + seq( + field('name', $.variable), + field('operator', choice(...COMPOUND_ASSIGN_OPERATORS)), + field('value', $.expression) + ), + + label_statement: ($) => seq('::', $.identifier, '::'), + + break_statement: (_) => 'break', + + goto_statement: ($) => seq('goto', $.identifier), + + do_statement: ($) => seq('do', field('body', optional_block($)), 'end'), + + while_statement: ($) => + seq( + 'while', + field('condition', $.expression), + 'do', + field('body', optional_block($)), + 'end' + ), + + // PICO-8 single-line: while (cond) stmt + shorthand_while_statement: ($) => + seq( + 'while', + '(', + field('condition', $.expression), + ')', + field('body', $.statement) + ), + + repeat_statement: ($) => + seq( + 'repeat', + field('body', optional_block($)), + 'until', + field('condition', $.expression) + ), + + if_statement: ($) => + seq( + 'if', + field('condition', $.expression), + 'then', + field('consequence', optional_block($)), + repeat(field('alternative', $.elseif_statement)), + optional(field('alternative', $.else_statement)), + 'end' + ), + elseif_statement: ($) => + seq( + 'elseif', + field('condition', $.expression), + 'then', + field('consequence', optional_block($)) + ), + else_statement: ($) => seq('else', field('body', optional_block($))), + + // PICO-8 single-line: if (cond) stmt [else stmt] + // prec.right resolves the dangling-else ambiguity in favor of greedy + // attach to the nearest preceding shorthand `if`, matching PICO-8 + // semantics where shorthand if/else live on one line. + shorthand_if_statement: ($) => + prec.right(seq( + 'if', + '(', + field('condition', $.expression), + ')', + field('consequence', $.statement), + optional(seq('else', field('alternative', $.statement))) + )), + + for_statement: ($) => + seq( + 'for', + field('clause', choice($.for_generic_clause, $.for_numeric_clause)), + 'do', + field('body', optional_block($)), + 'end' + ), + for_generic_clause: ($) => + seq( + alias($._name_list, $.variable_list), + 'in', + alias($._expression_list, $.expression_list) + ), + for_numeric_clause: ($) => + seq( + field('name', $.identifier), + field('operator', '='), + field('start', $.expression), + ',', + field('end', $.expression), + optional(seq(',', field('step', $.expression))) + ), + _name_list: ($) => name_list($), + + declaration: ($) => + choice( + $.function_declaration, + field( + 'local_declaration', + alias($._local_function_declaration, $.function_declaration) + ), + field('local_declaration', $.variable_declaration), + ), + function_declaration: ($) => + seq('function', field('name', $._function_name), $._function_body), + _local_function_declaration: ($) => + seq('local', 'function', field('name', $.identifier), $._function_body), + _function_name: ($) => + choice( + $._function_name_prefix_expression, + alias( + $._function_name_method_index_expression, + $.method_index_expression + ) + ), + _function_name_prefix_expression: ($) => + choice( + $.identifier, + alias($._function_name_dot_index_expression, $.dot_index_expression) + ), + _function_name_dot_index_expression: ($) => + seq( + field('table', $._function_name_prefix_expression), + '.', + field('field', $.identifier) + ), + _function_name_method_index_expression: ($) => + seq( + field('table', $._function_name_prefix_expression), + ':', + field('method', $.identifier) + ), + + variable_declaration: ($) => + seq( + 'local', + choice( + alias($._att_name_list, $.variable_list), + alias($._variable_assignment, $.assignment_statement) + ) + ), + _variable_assignment: ($) => + seq( + alias($._att_name_list, $.variable_list), + field('operator', '='), + alias($._variable_assignment_explist, $.expression_list) + ), + + _att_name_list: ($) => + seq( + optional(field('attribute', alias($._attrib, $.attribute))), + list_seq( + seq( + field('name', $.identifier), + optional(field('attribute', alias($._attrib, $.attribute))) + ), + ',' + ), + ), + _attrib: ($) => seq('<', $.identifier, '>'), + + _expression_list: ($) => list_seq($.expression, ','), + + // PICO-8 print shorthand: ? expr {, expr} + print_shorthand_statement: ($) => + seq( + field('directive', '?'), + list_seq(field('argument', $.expression), ',') + ), + + // PICO-8 include directive: #include path + // Tokenized greedily as `#include` + whitespace so that the standalone + // `#` (unary length operator) and identifier-starting `#x` continue to + // parse as length-of-expression. + include_statement: ($) => + seq( + field('directive', alias(token(prec(2, /#include[ \t]+/)), '#include')), + field('path', alias(/[^\n\r]*/, $.include_path)) + ), + + expression: ($) => + choice( + $.nil, + $.false, + $.true, + $.number, + $.string, + $.vararg_expression, + $.function_definition, + $.variable, + $.function_call, + $.parenthesized_expression, + $.table_constructor, + $.binary_expression, + $.unary_expression + ), + + nil: (_) => 'nil', + false: (_) => 'false', + true: (_) => 'true', + + number: (_) => { + function number_literal(digits, exponent_marker, exponent_digits) { + return seq( + choice( + seq(optional(digits), optional('.'), digits), + seq(digits, optional('.'), optional(digits)) + ), + optional( + seq( + choice( + exponent_marker.toLowerCase(), + exponent_marker.toUpperCase() + ), + seq(optional(choice('-', '+')), exponent_digits) + ) + ) + ); + } + + const decimal_digits = /[0-9]+/; + const decimal_literal = number_literal(decimal_digits, 'e', decimal_digits); + + const hex_digits = /[a-fA-F0-9]+/; + const hex_literal = seq( + choice('0x', '0X'), + number_literal(hex_digits, 'p', decimal_digits) + ); + + const bin_digits = /[01]+/; + const bin_literal = seq(choice('0b', '0B'), bin_digits); + + return token(choice(decimal_literal, hex_literal, bin_literal)); + }, + + string: ($) => choice($._quote_string, $._block_string), + + _quote_string: ($) => + choice( + seq( + field('start', alias('"', '"')), + field( + 'content', + optional(alias($._doublequote_string_content, $.string_content)) + ), + field('end', alias('"', '"')) + ), + seq( + field('start', alias("'", "'")), + field( + 'content', + optional(alias($._singlequote_string_content, $.string_content)) + ), + field('end', alias("'", "'")) + ) + ), + + _doublequote_string_content: ($) => + repeat1(choice(token.immediate(prec(1, /[^"\\]+/)), $.escape_sequence)), + + _singlequote_string_content: ($) => + repeat1(choice(token.immediate(prec(1, /[^'\\]+/)), $.escape_sequence)), + + _block_string: ($) => + seq( + field('start', alias($._block_string_start, '[[')), + field('content', alias($._block_string_content, $.string_content)), + field('end', alias($._block_string_end, ']]')) + ), + + escape_sequence: () => + token.immediate( + seq( + '\\', + choice( + /[\nabfnrtv\\'"]/, + /z\s*/, + /[0-9]{1,3}/, + /x[0-9a-fA-F]{2}/, + /u\{[0-9a-fA-F]+\}/ + ) + ) + ), + + vararg_expression: (_) => '...', + + function_definition: ($) => seq('function', $._function_body), + _function_body: ($) => + seq( + field('parameters', $.parameters), + field('body', optional_block($)), + 'end' + ), + parameters: ($) => seq('(', optional($._parameter_list), ')'), + _parameter_list: ($) => + choice( + seq(name_list($), optional(seq(',', $._vararg_parameter))), + $._vararg_parameter + ), + _vararg_parameter: ($) => + seq($.vararg_expression, optional(field('name', $.identifier))), + + _prefix_expression: ($) => + prec(1, choice($.variable, $.function_call, $.parenthesized_expression)), + + variable: ($) => + choice($.identifier, $.bracket_index_expression, $.dot_index_expression), + bracket_index_expression: ($) => + seq( + field('table', $._prefix_expression), + '[', + field('field', $.expression), + ']' + ), + dot_index_expression: ($) => + seq( + field('table', $._prefix_expression), + '.', + field('field', $.identifier) + ), + + function_call: ($) => + seq( + field('name', choice($._prefix_expression, $.method_index_expression)), + field('arguments', $.arguments) + ), + method_index_expression: ($) => + seq( + field('table', $._prefix_expression), + ':', + field('method', $.identifier) + ), + arguments: ($) => + choice( + seq('(', optional(list_seq($.expression, ',')), ')'), + $.table_constructor, + $.string + ), + + parenthesized_expression: ($) => seq('(', $.expression, ')'), + + table_constructor: ($) => seq('{', optional($._field_list), '}'), + _field_list: ($) => list_seq($.field, $._field_sep, true), + _field_sep: (_) => choice(',', ';'), + field: ($) => + choice( + seq( + '[', + field('name', $.expression), + ']', + field('operator', '='), + field('value', $.expression) + ), + seq(field('name', $.identifier), '=', field('value', $.expression)), + field('value', $.expression) + ), + + binary_expression: ($) => + choice( + ...[ + ['or', PREC.OR], + ['and', PREC.AND], + ['<', PREC.COMPARE], + ['<=', PREC.COMPARE], + ['==', PREC.COMPARE], + ['~=', PREC.COMPARE], + ['!=', PREC.COMPARE], // PICO-8 alias for ~= + ['>=', PREC.COMPARE], + ['>', PREC.COMPARE], + ['|', PREC.BIT_OR], + ['~', PREC.BIT_NOT], // bitwise xor (Lua 5.3 binary form) + ['^^', PREC.BIT_NOT], // PICO-8 bitwise xor + ['&', PREC.BIT_AND], + ['<<', PREC.BIT_SHIFT], + ['>>', PREC.BIT_SHIFT], + ['>>>', PREC.BIT_SHIFT], // PICO-8 logical shift right + ['<<>', PREC.BIT_SHIFT], // PICO-8 rotate left + ['>><', PREC.BIT_SHIFT], // PICO-8 rotate right + ['+', PREC.PLUS], + ['-', PREC.PLUS], + ['*', PREC.MULTI], + ['/', PREC.MULTI], + ['//', PREC.MULTI], + ['%', PREC.MULTI], + ['\\', PREC.MULTI], // PICO-8 integer divide + ].map(([operator, precedence]) => + prec.left( + precedence, + seq( + field('left', $.expression), + field('operator', operator), + field('right', $.expression) + ) + ) + ), + ...[ + ['..', PREC.CONCAT], + ['^', PREC.POWER], + ].map(([operator, precedence]) => + prec.right( + precedence, + seq( + field('left', $.expression), + field('operator', operator), + field('right', $.expression) + ) + ) + ) + ), + + unary_expression: ($) => + prec.left( + PREC.UNARY, + seq( + // @ $ % are PICO-8 peek prefixes ( peek / peek4 / peek2 ). + // % collides lexically with binary modulo; the GLR parser + // resolves usage by surrounding context. + field('operator', choice('not', '#', '-', '~', '@', '$', '%')), + field('operand', $.expression), + ) + ), + + identifier: (_) => { + // PICO-8 dialect carves out !, ?, @, $ as operator tokens, so they + // are not valid in identifiers ( upstream allowed them ). + const identifier_start = + /[^\p{Control}\s!?@$+\-*/%^#&~|<>=(){}\[\];:,.\\'"\d]/; + const identifier_continue = + /[^\p{Control}\s!?@$+\-*/%^#&~|<>=(){}\[\];:,.\\'"]*/; + return token(seq(identifier_start, identifier_continue)); + }, + + comment: ($) => + choice( + seq( + field('start', '--'), + field('content', alias(/[^\r\n]*/, $.comment_content)) + ), + seq( + field('start', alias($._block_comment_start, '[[')), + field('content', alias($._block_comment_content, $.comment_content)), + field('end', alias($._block_comment_end, ']]')) + ) + ), + }, +}); diff --git a/grammars/pico-8-lua/package.json b/grammars/pico-8-lua/package.json new file mode 100644 index 0000000..fde1f8b --- /dev/null +++ b/grammars/pico-8-lua/package.json @@ -0,0 +1,7 @@ +{ + "name": "tree-sitter-pico8-lua", + "version": "0.0.1", + "description": "tree-sitter grammar for the PICO-8 Lua dialect (forked from tree-sitter-lua)", + "type": "module", + "license": "MIT" +} diff --git a/grammars/pico-8-lua/src/grammar.json b/grammars/pico-8-lua/src/grammar.json new file mode 100644 index 0000000..01a4529 --- /dev/null +++ b/grammars/pico-8-lua/src/grammar.json @@ -0,0 +1,3708 @@ +{ + "$schema": "https://tree-sitter.github.io/tree-sitter/assets/schemas/grammar.schema.json", + "name": "pico8_lua", + "word": "identifier", + "rules": { + "chunk": { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "hash_bang_line" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "REPEAT", + "content": { + "type": "SYMBOL", + "name": "statement" + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "return_statement" + }, + { + "type": "BLANK" + } + ] + } + ] + }, + "hash_bang_line": { + "type": "PATTERN", + "value": "#![^\\n]*" + }, + "_block": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "REPEAT1", + "content": { + "type": "SYMBOL", + "name": "statement" + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "return_statement" + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "REPEAT", + "content": { + "type": "SYMBOL", + "name": "statement" + } + }, + { + "type": "SYMBOL", + "name": "return_statement" + } + ] + } + ] + }, + "statement": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "empty_statement" + }, + { + "type": "SYMBOL", + "name": "assignment_statement" + }, + { + "type": "SYMBOL", + "name": "compound_assignment_statement" + }, + { + "type": "SYMBOL", + "name": "function_call" + }, + { + "type": "SYMBOL", + "name": "label_statement" + }, + { + "type": "SYMBOL", + "name": "break_statement" + }, + { + "type": "SYMBOL", + "name": "goto_statement" + }, + { + "type": "SYMBOL", + "name": "do_statement" + }, + { + "type": "SYMBOL", + "name": "while_statement" + }, + { + "type": "SYMBOL", + "name": "shorthand_while_statement" + }, + { + "type": "SYMBOL", + "name": "repeat_statement" + }, + { + "type": "SYMBOL", + "name": "if_statement" + }, + { + "type": "SYMBOL", + "name": "shorthand_if_statement" + }, + { + "type": "SYMBOL", + "name": "for_statement" + }, + { + "type": "SYMBOL", + "name": "declaration" + }, + { + "type": "SYMBOL", + "name": "print_shorthand_statement" + }, + { + "type": "SYMBOL", + "name": "include_statement" + } + ] + }, + "return_statement": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "return" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_expression_list" + }, + "named": true, + "value": "expression_list" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": ";" + }, + { + "type": "BLANK" + } + ] + } + ] + }, + "empty_statement": { + "type": "STRING", + "value": ";" + }, + "assignment_statement": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_variable_assignment_varlist" + }, + "named": true, + "value": "variable_list" + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": "=" + } + }, + { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_variable_assignment_explist" + }, + "named": true, + "value": "expression_list" + } + ] + }, + "_variable_assignment_varlist": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "variable" + } + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "variable" + } + } + ] + } + } + ] + }, + "_variable_assignment_explist": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "value", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "FIELD", + "name": "value", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + } + } + ] + }, + "compound_assignment_statement": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "variable" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "+=" + }, + { + "type": "STRING", + "value": "-=" + }, + { + "type": "STRING", + "value": "*=" + }, + { + "type": "STRING", + "value": "/=" + }, + { + "type": "STRING", + "value": "%=" + }, + { + "type": "STRING", + "value": "\\=" + }, + { + "type": "STRING", + "value": "^=" + }, + { + "type": "STRING", + "value": "..=" + }, + { + "type": "STRING", + "value": "&=" + }, + { + "type": "STRING", + "value": "|=" + }, + { + "type": "STRING", + "value": "^^=" + }, + { + "type": "STRING", + "value": "<<=" + }, + { + "type": "STRING", + "value": ">>=" + }, + { + "type": "STRING", + "value": ">>>=" + }, + { + "type": "STRING", + "value": "<<>=" + }, + { + "type": "STRING", + "value": ">><=" + } + ] + } + }, + { + "type": "FIELD", + "name": "value", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + }, + "label_statement": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "::" + }, + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "STRING", + "value": "::" + } + ] + }, + "break_statement": { + "type": "STRING", + "value": "break" + }, + "goto_statement": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "goto" + }, + { + "type": "SYMBOL", + "name": "identifier" + } + ] + }, + "do_statement": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "do" + }, + { + "type": "FIELD", + "name": "body", + "content": { + "type": "ALIAS", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_block" + }, + { + "type": "BLANK" + } + ] + }, + "named": true, + "value": "block" + } + }, + { + "type": "STRING", + "value": "end" + } + ] + }, + "while_statement": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "while" + }, + { + "type": "FIELD", + "name": "condition", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "STRING", + "value": "do" + }, + { + "type": "FIELD", + "name": "body", + "content": { + "type": "ALIAS", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_block" + }, + { + "type": "BLANK" + } + ] + }, + "named": true, + "value": "block" + } + }, + { + "type": "STRING", + "value": "end" + } + ] + }, + "shorthand_while_statement": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "while" + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "FIELD", + "name": "condition", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "STRING", + "value": ")" + }, + { + "type": "FIELD", + "name": "body", + "content": { + "type": "SYMBOL", + "name": "statement" + } + } + ] + }, + "repeat_statement": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "repeat" + }, + { + "type": "FIELD", + "name": "body", + "content": { + "type": "ALIAS", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_block" + }, + { + "type": "BLANK" + } + ] + }, + "named": true, + "value": "block" + } + }, + { + "type": "STRING", + "value": "until" + }, + { + "type": "FIELD", + "name": "condition", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + }, + "if_statement": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "if" + }, + { + "type": "FIELD", + "name": "condition", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "STRING", + "value": "then" + }, + { + "type": "FIELD", + "name": "consequence", + "content": { + "type": "ALIAS", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_block" + }, + { + "type": "BLANK" + } + ] + }, + "named": true, + "value": "block" + } + }, + { + "type": "REPEAT", + "content": { + "type": "FIELD", + "name": "alternative", + "content": { + "type": "SYMBOL", + "name": "elseif_statement" + } + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "FIELD", + "name": "alternative", + "content": { + "type": "SYMBOL", + "name": "else_statement" + } + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": "end" + } + ] + }, + "elseif_statement": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "elseif" + }, + { + "type": "FIELD", + "name": "condition", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "STRING", + "value": "then" + }, + { + "type": "FIELD", + "name": "consequence", + "content": { + "type": "ALIAS", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_block" + }, + { + "type": "BLANK" + } + ] + }, + "named": true, + "value": "block" + } + } + ] + }, + "else_statement": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "else" + }, + { + "type": "FIELD", + "name": "body", + "content": { + "type": "ALIAS", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_block" + }, + { + "type": "BLANK" + } + ] + }, + "named": true, + "value": "block" + } + } + ] + }, + "shorthand_if_statement": { + "type": "PREC_RIGHT", + "value": 0, + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "if" + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "FIELD", + "name": "condition", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "STRING", + "value": ")" + }, + { + "type": "FIELD", + "name": "consequence", + "content": { + "type": "SYMBOL", + "name": "statement" + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "else" + }, + { + "type": "FIELD", + "name": "alternative", + "content": { + "type": "SYMBOL", + "name": "statement" + } + } + ] + }, + { + "type": "BLANK" + } + ] + } + ] + } + }, + "for_statement": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "for" + }, + { + "type": "FIELD", + "name": "clause", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "for_generic_clause" + }, + { + "type": "SYMBOL", + "name": "for_numeric_clause" + } + ] + } + }, + { + "type": "STRING", + "value": "do" + }, + { + "type": "FIELD", + "name": "body", + "content": { + "type": "ALIAS", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_block" + }, + { + "type": "BLANK" + } + ] + }, + "named": true, + "value": "block" + } + }, + { + "type": "STRING", + "value": "end" + } + ] + }, + "for_generic_clause": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_name_list" + }, + "named": true, + "value": "variable_list" + }, + { + "type": "STRING", + "value": "in" + }, + { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_expression_list" + }, + "named": true, + "value": "expression_list" + } + ] + }, + "for_numeric_clause": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "identifier" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": "=" + } + }, + { + "type": "FIELD", + "name": "start", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "STRING", + "value": "," + }, + { + "type": "FIELD", + "name": "end", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "FIELD", + "name": "step", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + }, + { + "type": "BLANK" + } + ] + } + ] + }, + "_name_list": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "identifier" + } + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "identifier" + } + } + ] + } + } + ] + }, + "declaration": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "function_declaration" + }, + { + "type": "FIELD", + "name": "local_declaration", + "content": { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_local_function_declaration" + }, + "named": true, + "value": "function_declaration" + } + }, + { + "type": "FIELD", + "name": "local_declaration", + "content": { + "type": "SYMBOL", + "name": "variable_declaration" + } + } + ] + }, + "function_declaration": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "function" + }, + { + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "_function_name" + } + }, + { + "type": "SYMBOL", + "name": "_function_body" + } + ] + }, + "_local_function_declaration": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "local" + }, + { + "type": "STRING", + "value": "function" + }, + { + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "identifier" + } + }, + { + "type": "SYMBOL", + "name": "_function_body" + } + ] + }, + "_function_name": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_function_name_prefix_expression" + }, + { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_function_name_method_index_expression" + }, + "named": true, + "value": "method_index_expression" + } + ] + }, + "_function_name_prefix_expression": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_function_name_dot_index_expression" + }, + "named": true, + "value": "dot_index_expression" + } + ] + }, + "_function_name_dot_index_expression": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "table", + "content": { + "type": "SYMBOL", + "name": "_function_name_prefix_expression" + } + }, + { + "type": "STRING", + "value": "." + }, + { + "type": "FIELD", + "name": "field", + "content": { + "type": "SYMBOL", + "name": "identifier" + } + } + ] + }, + "_function_name_method_index_expression": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "table", + "content": { + "type": "SYMBOL", + "name": "_function_name_prefix_expression" + } + }, + { + "type": "STRING", + "value": ":" + }, + { + "type": "FIELD", + "name": "method", + "content": { + "type": "SYMBOL", + "name": "identifier" + } + } + ] + }, + "variable_declaration": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "local" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_att_name_list" + }, + "named": true, + "value": "variable_list" + }, + { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_variable_assignment" + }, + "named": true, + "value": "assignment_statement" + } + ] + } + ] + }, + "_variable_assignment": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_att_name_list" + }, + "named": true, + "value": "variable_list" + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": "=" + } + }, + { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_variable_assignment_explist" + }, + "named": true, + "value": "expression_list" + } + ] + }, + "_att_name_list": { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "FIELD", + "name": "attribute", + "content": { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_attrib" + }, + "named": true, + "value": "attribute" + } + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "identifier" + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "FIELD", + "name": "attribute", + "content": { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_attrib" + }, + "named": true, + "value": "attribute" + } + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "identifier" + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "FIELD", + "name": "attribute", + "content": { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_attrib" + }, + "named": true, + "value": "attribute" + } + }, + { + "type": "BLANK" + } + ] + } + ] + } + ] + } + } + ] + } + ] + }, + "_attrib": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "<" + }, + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "STRING", + "value": ">" + } + ] + }, + "_expression_list": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + } + } + ] + }, + "print_shorthand_statement": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "directive", + "content": { + "type": "STRING", + "value": "?" + } + }, + { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "argument", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "FIELD", + "name": "argument", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + } + } + ] + } + ] + }, + "include_statement": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "directive", + "content": { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 2, + "content": { + "type": "PATTERN", + "value": "#include[ \\t]+" + } + } + }, + "named": false, + "value": "#include" + } + }, + { + "type": "FIELD", + "name": "path", + "content": { + "type": "ALIAS", + "content": { + "type": "PATTERN", + "value": "[^\\n\\r]*" + }, + "named": true, + "value": "include_path" + } + } + ] + }, + "expression": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "nil" + }, + { + "type": "SYMBOL", + "name": "false" + }, + { + "type": "SYMBOL", + "name": "true" + }, + { + "type": "SYMBOL", + "name": "number" + }, + { + "type": "SYMBOL", + "name": "string" + }, + { + "type": "SYMBOL", + "name": "vararg_expression" + }, + { + "type": "SYMBOL", + "name": "function_definition" + }, + { + "type": "SYMBOL", + "name": "variable" + }, + { + "type": "SYMBOL", + "name": "function_call" + }, + { + "type": "SYMBOL", + "name": "parenthesized_expression" + }, + { + "type": "SYMBOL", + "name": "table_constructor" + }, + { + "type": "SYMBOL", + "name": "binary_expression" + }, + { + "type": "SYMBOL", + "name": "unary_expression" + } + ] + }, + "nil": { + "type": "STRING", + "value": "nil" + }, + "false": { + "type": "STRING", + "value": "false" + }, + "true": { + "type": "STRING", + "value": "true" + }, + "number": { + "type": "TOKEN", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "PATTERN", + "value": "[0-9]+" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "." + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "PATTERN", + "value": "[0-9]+" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "PATTERN", + "value": "[0-9]+" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "." + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "PATTERN", + "value": "[0-9]+" + }, + { + "type": "BLANK" + } + ] + } + ] + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "e" + }, + { + "type": "STRING", + "value": "E" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "-" + }, + { + "type": "STRING", + "value": "+" + } + ] + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "PATTERN", + "value": "[0-9]+" + } + ] + } + ] + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "0x" + }, + { + "type": "STRING", + "value": "0X" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "PATTERN", + "value": "[a-fA-F0-9]+" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "." + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "PATTERN", + "value": "[a-fA-F0-9]+" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "PATTERN", + "value": "[a-fA-F0-9]+" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "." + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "PATTERN", + "value": "[a-fA-F0-9]+" + }, + { + "type": "BLANK" + } + ] + } + ] + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "p" + }, + { + "type": "STRING", + "value": "P" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "-" + }, + { + "type": "STRING", + "value": "+" + } + ] + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "PATTERN", + "value": "[0-9]+" + } + ] + } + ] + }, + { + "type": "BLANK" + } + ] + } + ] + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "0b" + }, + { + "type": "STRING", + "value": "0B" + } + ] + }, + { + "type": "PATTERN", + "value": "[01]+" + } + ] + } + ] + } + }, + "string": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_quote_string" + }, + { + "type": "SYMBOL", + "name": "_block_string" + } + ] + }, + "_quote_string": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "start", + "content": { + "type": "ALIAS", + "content": { + "type": "STRING", + "value": "\"" + }, + "named": false, + "value": "\"" + } + }, + { + "type": "FIELD", + "name": "content", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_doublequote_string_content" + }, + "named": true, + "value": "string_content" + }, + { + "type": "BLANK" + } + ] + } + }, + { + "type": "FIELD", + "name": "end", + "content": { + "type": "ALIAS", + "content": { + "type": "STRING", + "value": "\"" + }, + "named": false, + "value": "\"" + } + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "start", + "content": { + "type": "ALIAS", + "content": { + "type": "STRING", + "value": "'" + }, + "named": false, + "value": "'" + } + }, + { + "type": "FIELD", + "name": "content", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_singlequote_string_content" + }, + "named": true, + "value": "string_content" + }, + { + "type": "BLANK" + } + ] + } + }, + { + "type": "FIELD", + "name": "end", + "content": { + "type": "ALIAS", + "content": { + "type": "STRING", + "value": "'" + }, + "named": false, + "value": "'" + } + } + ] + } + ] + }, + "_doublequote_string_content": { + "type": "REPEAT1", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "IMMEDIATE_TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[^\"\\\\]+" + } + } + }, + { + "type": "SYMBOL", + "name": "escape_sequence" + } + ] + } + }, + "_singlequote_string_content": { + "type": "REPEAT1", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "IMMEDIATE_TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[^'\\\\]+" + } + } + }, + { + "type": "SYMBOL", + "name": "escape_sequence" + } + ] + } + }, + "_block_string": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "start", + "content": { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_block_string_start" + }, + "named": false, + "value": "[[" + } + }, + { + "type": "FIELD", + "name": "content", + "content": { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_block_string_content" + }, + "named": true, + "value": "string_content" + } + }, + { + "type": "FIELD", + "name": "end", + "content": { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_block_string_end" + }, + "named": false, + "value": "]]" + } + } + ] + }, + "escape_sequence": { + "type": "IMMEDIATE_TOKEN", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "\\" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "PATTERN", + "value": "[\\nabfnrtv\\\\'\"]" + }, + { + "type": "PATTERN", + "value": "z\\s*" + }, + { + "type": "PATTERN", + "value": "[0-9]{1,3}" + }, + { + "type": "PATTERN", + "value": "x[0-9a-fA-F]{2}" + }, + { + "type": "PATTERN", + "value": "u\\{[0-9a-fA-F]+\\}" + } + ] + } + ] + } + }, + "vararg_expression": { + "type": "STRING", + "value": "..." + }, + "function_definition": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "function" + }, + { + "type": "SYMBOL", + "name": "_function_body" + } + ] + }, + "_function_body": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "parameters", + "content": { + "type": "SYMBOL", + "name": "parameters" + } + }, + { + "type": "FIELD", + "name": "body", + "content": { + "type": "ALIAS", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_block" + }, + { + "type": "BLANK" + } + ] + }, + "named": true, + "value": "block" + } + }, + { + "type": "STRING", + "value": "end" + } + ] + }, + "parameters": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "(" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_parameter_list" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": ")" + } + ] + }, + "_parameter_list": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "identifier" + } + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "identifier" + } + } + ] + } + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "_vararg_parameter" + } + ] + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "SYMBOL", + "name": "_vararg_parameter" + } + ] + }, + "_vararg_parameter": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "vararg_expression" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "identifier" + } + }, + { + "type": "BLANK" + } + ] + } + ] + }, + "_prefix_expression": { + "type": "PREC", + "value": 1, + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "variable" + }, + { + "type": "SYMBOL", + "name": "function_call" + }, + { + "type": "SYMBOL", + "name": "parenthesized_expression" + } + ] + } + }, + "variable": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "SYMBOL", + "name": "bracket_index_expression" + }, + { + "type": "SYMBOL", + "name": "dot_index_expression" + } + ] + }, + "bracket_index_expression": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "table", + "content": { + "type": "SYMBOL", + "name": "_prefix_expression" + } + }, + { + "type": "STRING", + "value": "[" + }, + { + "type": "FIELD", + "name": "field", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "STRING", + "value": "]" + } + ] + }, + "dot_index_expression": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "table", + "content": { + "type": "SYMBOL", + "name": "_prefix_expression" + } + }, + { + "type": "STRING", + "value": "." + }, + { + "type": "FIELD", + "name": "field", + "content": { + "type": "SYMBOL", + "name": "identifier" + } + } + ] + }, + "function_call": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "name", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_prefix_expression" + }, + { + "type": "SYMBOL", + "name": "method_index_expression" + } + ] + } + }, + { + "type": "FIELD", + "name": "arguments", + "content": { + "type": "SYMBOL", + "name": "arguments" + } + } + ] + }, + "method_index_expression": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "table", + "content": { + "type": "SYMBOL", + "name": "_prefix_expression" + } + }, + { + "type": "STRING", + "value": ":" + }, + { + "type": "FIELD", + "name": "method", + "content": { + "type": "SYMBOL", + "name": "identifier" + } + } + ] + }, + "arguments": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "(" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + } + } + ] + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": ")" + } + ] + }, + { + "type": "SYMBOL", + "name": "table_constructor" + }, + { + "type": "SYMBOL", + "name": "string" + } + ] + }, + "parenthesized_expression": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "(" + }, + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": ")" + } + ] + }, + "table_constructor": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "{" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_field_list" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": "}" + } + ] + }, + "_field_list": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "field" + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "_field_sep" + }, + { + "type": "SYMBOL", + "name": "field" + } + ] + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_field_sep" + }, + { + "type": "BLANK" + } + ] + } + ] + }, + "_field_sep": { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "STRING", + "value": ";" + } + ] + }, + "field": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "[" + }, + { + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "STRING", + "value": "]" + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": "=" + } + }, + { + "type": "FIELD", + "name": "value", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "identifier" + } + }, + { + "type": "STRING", + "value": "=" + }, + { + "type": "FIELD", + "name": "value", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + }, + { + "type": "FIELD", + "name": "value", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + }, + "binary_expression": { + "type": "CHOICE", + "members": [ + { + "type": "PREC_LEFT", + "value": 1, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": "or" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 2, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": "and" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 3, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": "<" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 3, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": "<=" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 3, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": "==" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 3, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": "~=" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 3, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": "!=" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 3, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": ">=" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 3, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": ">" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 4, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": "|" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 5, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": "~" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 5, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": "^^" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 6, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": "&" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 7, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": "<<" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 7, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": ">>" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 7, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": ">>>" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 7, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": "<<>" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 7, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": ">><" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 9, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": "+" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 9, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": "-" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 10, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": "*" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 10, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": "/" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 10, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": "//" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 10, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": "%" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 10, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": "\\" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + } + }, + { + "type": "PREC_RIGHT", + "value": 8, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": ".." + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + } + }, + { + "type": "PREC_RIGHT", + "value": 12, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": "^" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + } + } + ] + }, + "unary_expression": { + "type": "PREC_LEFT", + "value": 11, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "not" + }, + { + "type": "STRING", + "value": "#" + }, + { + "type": "STRING", + "value": "-" + }, + { + "type": "STRING", + "value": "~" + }, + { + "type": "STRING", + "value": "@" + }, + { + "type": "STRING", + "value": "$" + }, + { + "type": "STRING", + "value": "%" + } + ] + } + }, + { + "type": "FIELD", + "name": "operand", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + } + }, + "identifier": { + "type": "TOKEN", + "content": { + "type": "SEQ", + "members": [ + { + "type": "PATTERN", + "value": "[^\\p{Control}\\s!?@$+\\-*/%^#&~|<>=(){}\\[\\];:,.\\\\'\"\\d]" + }, + { + "type": "PATTERN", + "value": "[^\\p{Control}\\s!?@$+\\-*/%^#&~|<>=(){}\\[\\];:,.\\\\'\"]*" + } + ] + } + }, + "comment": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "start", + "content": { + "type": "STRING", + "value": "--" + } + }, + { + "type": "FIELD", + "name": "content", + "content": { + "type": "ALIAS", + "content": { + "type": "PATTERN", + "value": "[^\\r\\n]*" + }, + "named": true, + "value": "comment_content" + } + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "start", + "content": { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_block_comment_start" + }, + "named": false, + "value": "[[" + } + }, + { + "type": "FIELD", + "name": "content", + "content": { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_block_comment_content" + }, + "named": true, + "value": "comment_content" + } + }, + { + "type": "FIELD", + "name": "end", + "content": { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_block_comment_end" + }, + "named": false, + "value": "]]" + } + } + ] + } + ] + } + }, + "extras": [ + { + "type": "SYMBOL", + "name": "comment" + }, + { + "type": "PATTERN", + "value": "\\s" + } + ], + "conflicts": [ + [ + "parenthesized_expression", + "shorthand_if_statement" + ], + [ + "parenthesized_expression", + "shorthand_while_statement" + ] + ], + "precedences": [], + "externals": [ + { + "type": "SYMBOL", + "name": "_block_comment_start" + }, + { + "type": "SYMBOL", + "name": "_block_comment_content" + }, + { + "type": "SYMBOL", + "name": "_block_comment_end" + }, + { + "type": "SYMBOL", + "name": "_block_string_start" + }, + { + "type": "SYMBOL", + "name": "_block_string_content" + }, + { + "type": "SYMBOL", + "name": "_block_string_end" + } + ], + "inline": [], + "supertypes": [ + "statement", + "expression", + "declaration", + "variable" + ] +} diff --git a/grammars/pico-8-lua/src/node-types.json b/grammars/pico-8-lua/src/node-types.json new file mode 100644 index 0000000..0d24113 --- /dev/null +++ b/grammars/pico-8-lua/src/node-types.json @@ -0,0 +1,1826 @@ +[ + { + "type": "declaration", + "named": true, + "subtypes": [ + { + "type": "function_declaration", + "named": true + }, + { + "type": "variable_declaration", + "named": true + } + ] + }, + { + "type": "expression", + "named": true, + "subtypes": [ + { + "type": "binary_expression", + "named": true + }, + { + "type": "false", + "named": true + }, + { + "type": "function_call", + "named": true + }, + { + "type": "function_definition", + "named": true + }, + { + "type": "nil", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "parenthesized_expression", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "table_constructor", + "named": true + }, + { + "type": "true", + "named": true + }, + { + "type": "unary_expression", + "named": true + }, + { + "type": "vararg_expression", + "named": true + }, + { + "type": "variable", + "named": true + } + ] + }, + { + "type": "statement", + "named": true, + "subtypes": [ + { + "type": "assignment_statement", + "named": true + }, + { + "type": "break_statement", + "named": true + }, + { + "type": "compound_assignment_statement", + "named": true + }, + { + "type": "declaration", + "named": true + }, + { + "type": "do_statement", + "named": true + }, + { + "type": "empty_statement", + "named": true + }, + { + "type": "for_statement", + "named": true + }, + { + "type": "function_call", + "named": true + }, + { + "type": "goto_statement", + "named": true + }, + { + "type": "if_statement", + "named": true + }, + { + "type": "include_statement", + "named": true + }, + { + "type": "label_statement", + "named": true + }, + { + "type": "print_shorthand_statement", + "named": true + }, + { + "type": "repeat_statement", + "named": true + }, + { + "type": "shorthand_if_statement", + "named": true + }, + { + "type": "shorthand_while_statement", + "named": true + }, + { + "type": "while_statement", + "named": true + } + ] + }, + { + "type": "variable", + "named": true, + "subtypes": [ + { + "type": "bracket_index_expression", + "named": true + }, + { + "type": "dot_index_expression", + "named": true + }, + { + "type": "identifier", + "named": true + } + ] + }, + { + "type": "arguments", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "expression", + "named": true + } + ] + } + }, + { + "type": "assignment_statement", + "named": true, + "fields": { + "operator": { + "multiple": false, + "required": true, + "types": [ + { + "type": "=", + "named": false + } + ] + } + }, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "expression_list", + "named": true + }, + { + "type": "variable_list", + "named": true + } + ] + } + }, + { + "type": "attribute", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + } + ] + } + }, + { + "type": "binary_expression", + "named": true, + "fields": { + "left": { + "multiple": false, + "required": true, + "types": [ + { + "type": "expression", + "named": true + } + ] + }, + "operator": { + "multiple": false, + "required": true, + "types": [ + { + "type": "!=", + "named": false + }, + { + "type": "%", + "named": false + }, + { + "type": "&", + "named": false + }, + { + "type": "*", + "named": false + }, + { + "type": "+", + "named": false + }, + { + "type": "-", + "named": false + }, + { + "type": "..", + "named": false + }, + { + "type": "/", + "named": false + }, + { + "type": "//", + "named": false + }, + { + "type": "<", + "named": false + }, + { + "type": "<<", + "named": false + }, + { + "type": "<<>", + "named": false + }, + { + "type": "<=", + "named": false + }, + { + "type": "==", + "named": false + }, + { + "type": ">", + "named": false + }, + { + "type": ">=", + "named": false + }, + { + "type": ">>", + "named": false + }, + { + "type": ">><", + "named": false + }, + { + "type": ">>>", + "named": false + }, + { + "type": "\\", + "named": false + }, + { + "type": "^", + "named": false + }, + { + "type": "^^", + "named": false + }, + { + "type": "and", + "named": false + }, + { + "type": "or", + "named": false + }, + { + "type": "|", + "named": false + }, + { + "type": "~", + "named": false + }, + { + "type": "~=", + "named": false + } + ] + }, + "right": { + "multiple": false, + "required": true, + "types": [ + { + "type": "expression", + "named": true + } + ] + } + } + }, + { + "type": "block", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "return_statement", + "named": true + }, + { + "type": "statement", + "named": true + } + ] + } + }, + { + "type": "bracket_index_expression", + "named": true, + "fields": { + "field": { + "multiple": false, + "required": true, + "types": [ + { + "type": "expression", + "named": true + } + ] + }, + "table": { + "multiple": false, + "required": true, + "types": [ + { + "type": "function_call", + "named": true + }, + { + "type": "parenthesized_expression", + "named": true + }, + { + "type": "variable", + "named": true + } + ] + } + } + }, + { + "type": "chunk", + "named": true, + "root": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "hash_bang_line", + "named": true + }, + { + "type": "return_statement", + "named": true + }, + { + "type": "statement", + "named": true + } + ] + } + }, + { + "type": "comment", + "named": true, + "fields": { + "content": { + "multiple": false, + "required": true, + "types": [ + { + "type": "comment_content", + "named": true + } + ] + }, + "end": { + "multiple": false, + "required": false, + "types": [ + { + "type": "]]", + "named": false + } + ] + }, + "start": { + "multiple": false, + "required": true, + "types": [ + { + "type": "--", + "named": false + }, + { + "type": "[[", + "named": false + } + ] + } + } + }, + { + "type": "compound_assignment_statement", + "named": true, + "fields": { + "name": { + "multiple": false, + "required": true, + "types": [ + { + "type": "variable", + "named": true + } + ] + }, + "operator": { + "multiple": false, + "required": true, + "types": [ + { + "type": "%=", + "named": false + }, + { + "type": "&=", + "named": false + }, + { + "type": "*=", + "named": false + }, + { + "type": "+=", + "named": false + }, + { + "type": "-=", + "named": false + }, + { + "type": "..=", + "named": false + }, + { + "type": "/=", + "named": false + }, + { + "type": "<<=", + "named": false + }, + { + "type": "<<>=", + "named": false + }, + { + "type": ">><=", + "named": false + }, + { + "type": ">>=", + "named": false + }, + { + "type": ">>>=", + "named": false + }, + { + "type": "\\=", + "named": false + }, + { + "type": "^=", + "named": false + }, + { + "type": "^^=", + "named": false + }, + { + "type": "|=", + "named": false + } + ] + }, + "value": { + "multiple": false, + "required": true, + "types": [ + { + "type": "expression", + "named": true + } + ] + } + } + }, + { + "type": "do_statement", + "named": true, + "fields": { + "body": { + "multiple": false, + "required": false, + "types": [ + { + "type": "block", + "named": true + } + ] + } + } + }, + { + "type": "dot_index_expression", + "named": true, + "fields": { + "field": { + "multiple": false, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + } + ] + }, + "table": { + "multiple": false, + "required": true, + "types": [ + { + "type": "function_call", + "named": true + }, + { + "type": "parenthesized_expression", + "named": true + }, + { + "type": "variable", + "named": true + } + ] + } + } + }, + { + "type": "else_statement", + "named": true, + "fields": { + "body": { + "multiple": false, + "required": false, + "types": [ + { + "type": "block", + "named": true + } + ] + } + } + }, + { + "type": "elseif_statement", + "named": true, + "fields": { + "condition": { + "multiple": false, + "required": true, + "types": [ + { + "type": "expression", + "named": true + } + ] + }, + "consequence": { + "multiple": false, + "required": false, + "types": [ + { + "type": "block", + "named": true + } + ] + } + } + }, + { + "type": "empty_statement", + "named": true, + "fields": {} + }, + { + "type": "expression_list", + "named": true, + "fields": { + "value": { + "multiple": true, + "required": false, + "types": [ + { + "type": "expression", + "named": true + } + ] + } + }, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "expression", + "named": true + } + ] + } + }, + { + "type": "field", + "named": true, + "fields": { + "name": { + "multiple": false, + "required": false, + "types": [ + { + "type": "expression", + "named": true + }, + { + "type": "identifier", + "named": true + } + ] + }, + "operator": { + "multiple": false, + "required": false, + "types": [ + { + "type": "=", + "named": false + } + ] + }, + "value": { + "multiple": false, + "required": true, + "types": [ + { + "type": "expression", + "named": true + } + ] + } + } + }, + { + "type": "for_generic_clause", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "expression_list", + "named": true + }, + { + "type": "variable_list", + "named": true + } + ] + } + }, + { + "type": "for_numeric_clause", + "named": true, + "fields": { + "end": { + "multiple": false, + "required": true, + "types": [ + { + "type": "expression", + "named": true + } + ] + }, + "name": { + "multiple": false, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + } + ] + }, + "operator": { + "multiple": false, + "required": true, + "types": [ + { + "type": "=", + "named": false + } + ] + }, + "start": { + "multiple": false, + "required": true, + "types": [ + { + "type": "expression", + "named": true + } + ] + }, + "step": { + "multiple": false, + "required": false, + "types": [ + { + "type": "expression", + "named": true + } + ] + } + } + }, + { + "type": "for_statement", + "named": true, + "fields": { + "body": { + "multiple": false, + "required": false, + "types": [ + { + "type": "block", + "named": true + } + ] + }, + "clause": { + "multiple": false, + "required": true, + "types": [ + { + "type": "for_generic_clause", + "named": true + }, + { + "type": "for_numeric_clause", + "named": true + } + ] + } + } + }, + { + "type": "function_call", + "named": true, + "fields": { + "arguments": { + "multiple": false, + "required": true, + "types": [ + { + "type": "arguments", + "named": true + } + ] + }, + "name": { + "multiple": false, + "required": true, + "types": [ + { + "type": "function_call", + "named": true + }, + { + "type": "method_index_expression", + "named": true + }, + { + "type": "parenthesized_expression", + "named": true + }, + { + "type": "variable", + "named": true + } + ] + } + } + }, + { + "type": "function_declaration", + "named": true, + "fields": { + "body": { + "multiple": false, + "required": false, + "types": [ + { + "type": "block", + "named": true + } + ] + }, + "name": { + "multiple": false, + "required": true, + "types": [ + { + "type": "dot_index_expression", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "method_index_expression", + "named": true + } + ] + }, + "parameters": { + "multiple": false, + "required": true, + "types": [ + { + "type": "parameters", + "named": true + } + ] + } + } + }, + { + "type": "function_definition", + "named": true, + "fields": { + "body": { + "multiple": false, + "required": false, + "types": [ + { + "type": "block", + "named": true + } + ] + }, + "parameters": { + "multiple": false, + "required": true, + "types": [ + { + "type": "parameters", + "named": true + } + ] + } + } + }, + { + "type": "goto_statement", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + } + ] + } + }, + { + "type": "if_statement", + "named": true, + "fields": { + "alternative": { + "multiple": true, + "required": false, + "types": [ + { + "type": "else_statement", + "named": true + }, + { + "type": "elseif_statement", + "named": true + } + ] + }, + "condition": { + "multiple": false, + "required": true, + "types": [ + { + "type": "expression", + "named": true + } + ] + }, + "consequence": { + "multiple": false, + "required": false, + "types": [ + { + "type": "block", + "named": true + } + ] + } + } + }, + { + "type": "include_statement", + "named": true, + "fields": { + "directive": { + "multiple": false, + "required": true, + "types": [ + { + "type": "#include", + "named": false + } + ] + }, + "path": { + "multiple": false, + "required": true, + "types": [ + { + "type": "include_path", + "named": true + } + ] + } + } + }, + { + "type": "label_statement", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + } + ] + } + }, + { + "type": "method_index_expression", + "named": true, + "fields": { + "method": { + "multiple": false, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + } + ] + }, + "table": { + "multiple": false, + "required": true, + "types": [ + { + "type": "function_call", + "named": true + }, + { + "type": "parenthesized_expression", + "named": true + }, + { + "type": "variable", + "named": true + } + ] + } + } + }, + { + "type": "parameters", + "named": true, + "fields": { + "name": { + "multiple": true, + "required": false, + "types": [ + { + "type": "identifier", + "named": true + } + ] + } + }, + "children": { + "multiple": false, + "required": false, + "types": [ + { + "type": "vararg_expression", + "named": true + } + ] + } + }, + { + "type": "parenthesized_expression", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "expression", + "named": true + } + ] + } + }, + { + "type": "print_shorthand_statement", + "named": true, + "fields": { + "argument": { + "multiple": true, + "required": true, + "types": [ + { + "type": "expression", + "named": true + } + ] + }, + "directive": { + "multiple": false, + "required": true, + "types": [ + { + "type": "?", + "named": false + } + ] + } + } + }, + { + "type": "repeat_statement", + "named": true, + "fields": { + "body": { + "multiple": false, + "required": false, + "types": [ + { + "type": "block", + "named": true + } + ] + }, + "condition": { + "multiple": false, + "required": true, + "types": [ + { + "type": "expression", + "named": true + } + ] + } + } + }, + { + "type": "return_statement", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": false, + "types": [ + { + "type": "expression_list", + "named": true + } + ] + } + }, + { + "type": "shorthand_if_statement", + "named": true, + "fields": { + "alternative": { + "multiple": false, + "required": false, + "types": [ + { + "type": "statement", + "named": true + } + ] + }, + "condition": { + "multiple": false, + "required": true, + "types": [ + { + "type": "expression", + "named": true + } + ] + }, + "consequence": { + "multiple": false, + "required": true, + "types": [ + { + "type": "statement", + "named": true + } + ] + } + } + }, + { + "type": "shorthand_while_statement", + "named": true, + "fields": { + "body": { + "multiple": false, + "required": true, + "types": [ + { + "type": "statement", + "named": true + } + ] + }, + "condition": { + "multiple": false, + "required": true, + "types": [ + { + "type": "expression", + "named": true + } + ] + } + } + }, + { + "type": "string", + "named": true, + "fields": { + "content": { + "multiple": false, + "required": false, + "types": [ + { + "type": "string_content", + "named": true + } + ] + }, + "end": { + "multiple": false, + "required": true, + "types": [ + { + "type": "\"", + "named": false + }, + { + "type": "'", + "named": false + }, + { + "type": "]]", + "named": false + } + ] + }, + "start": { + "multiple": false, + "required": true, + "types": [ + { + "type": "\"", + "named": false + }, + { + "type": "'", + "named": false + }, + { + "type": "[[", + "named": false + } + ] + } + } + }, + { + "type": "string_content", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "escape_sequence", + "named": true + } + ] + } + }, + { + "type": "table_constructor", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "field", + "named": true + } + ] + } + }, + { + "type": "unary_expression", + "named": true, + "fields": { + "operand": { + "multiple": false, + "required": true, + "types": [ + { + "type": "expression", + "named": true + } + ] + }, + "operator": { + "multiple": false, + "required": true, + "types": [ + { + "type": "#", + "named": false + }, + { + "type": "$", + "named": false + }, + { + "type": "%", + "named": false + }, + { + "type": "-", + "named": false + }, + { + "type": "@", + "named": false + }, + { + "type": "not", + "named": false + }, + { + "type": "~", + "named": false + } + ] + } + } + }, + { + "type": "variable_declaration", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "assignment_statement", + "named": true + }, + { + "type": "variable_list", + "named": true + } + ] + } + }, + { + "type": "variable_list", + "named": true, + "fields": { + "attribute": { + "multiple": true, + "required": false, + "types": [ + { + "type": "attribute", + "named": true + } + ] + }, + "name": { + "multiple": true, + "required": true, + "types": [ + { + "type": "variable", + "named": true + } + ] + } + } + }, + { + "type": "while_statement", + "named": true, + "fields": { + "body": { + "multiple": false, + "required": false, + "types": [ + { + "type": "block", + "named": true + } + ] + }, + "condition": { + "multiple": false, + "required": true, + "types": [ + { + "type": "expression", + "named": true + } + ] + } + } + }, + { + "type": "!=", + "named": false + }, + { + "type": "\"", + "named": false + }, + { + "type": "#", + "named": false + }, + { + "type": "#include", + "named": false + }, + { + "type": "$", + "named": false + }, + { + "type": "%", + "named": false + }, + { + "type": "%=", + "named": false + }, + { + "type": "&", + "named": false + }, + { + "type": "&=", + "named": false + }, + { + "type": "'", + "named": false + }, + { + "type": "(", + "named": false + }, + { + "type": ")", + "named": false + }, + { + "type": "*", + "named": false + }, + { + "type": "*=", + "named": false + }, + { + "type": "+", + "named": false + }, + { + "type": "+=", + "named": false + }, + { + "type": ",", + "named": false + }, + { + "type": "-", + "named": false + }, + { + "type": "--", + "named": false + }, + { + "type": "-=", + "named": false + }, + { + "type": ".", + "named": false + }, + { + "type": "..", + "named": false + }, + { + "type": "..=", + "named": false + }, + { + "type": "/", + "named": false + }, + { + "type": "//", + "named": false + }, + { + "type": "/=", + "named": false + }, + { + "type": ":", + "named": false + }, + { + "type": "::", + "named": false + }, + { + "type": ";", + "named": false + }, + { + "type": "<", + "named": false + }, + { + "type": "<<", + "named": false + }, + { + "type": "<<=", + "named": false + }, + { + "type": "<<>", + "named": false + }, + { + "type": "<<>=", + "named": false + }, + { + "type": "<=", + "named": false + }, + { + "type": "=", + "named": false + }, + { + "type": "==", + "named": false + }, + { + "type": ">", + "named": false + }, + { + "type": ">=", + "named": false + }, + { + "type": ">>", + "named": false + }, + { + "type": ">><", + "named": false + }, + { + "type": ">><=", + "named": false + }, + { + "type": ">>=", + "named": false + }, + { + "type": ">>>", + "named": false + }, + { + "type": ">>>=", + "named": false + }, + { + "type": "?", + "named": false + }, + { + "type": "@", + "named": false + }, + { + "type": "[", + "named": false + }, + { + "type": "[[", + "named": false + }, + { + "type": "\\", + "named": false + }, + { + "type": "\\=", + "named": false + }, + { + "type": "]", + "named": false + }, + { + "type": "]]", + "named": false + }, + { + "type": "^", + "named": false + }, + { + "type": "^=", + "named": false + }, + { + "type": "^^", + "named": false + }, + { + "type": "^^=", + "named": false + }, + { + "type": "and", + "named": false + }, + { + "type": "break_statement", + "named": true + }, + { + "type": "comment_content", + "named": true + }, + { + "type": "do", + "named": false + }, + { + "type": "else", + "named": false + }, + { + "type": "elseif", + "named": false + }, + { + "type": "end", + "named": false + }, + { + "type": "escape_sequence", + "named": true + }, + { + "type": "false", + "named": true + }, + { + "type": "for", + "named": false + }, + { + "type": "function", + "named": false + }, + { + "type": "goto", + "named": false + }, + { + "type": "hash_bang_line", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "if", + "named": false + }, + { + "type": "in", + "named": false + }, + { + "type": "include_path", + "named": true + }, + { + "type": "local", + "named": false + }, + { + "type": "nil", + "named": true + }, + { + "type": "not", + "named": false + }, + { + "type": "number", + "named": true + }, + { + "type": "or", + "named": false + }, + { + "type": "repeat", + "named": false + }, + { + "type": "return", + "named": false + }, + { + "type": "then", + "named": false + }, + { + "type": "true", + "named": true + }, + { + "type": "until", + "named": false + }, + { + "type": "vararg_expression", + "named": true + }, + { + "type": "while", + "named": false + }, + { + "type": "{", + "named": false + }, + { + "type": "|", + "named": false + }, + { + "type": "|=", + "named": false + }, + { + "type": "}", + "named": false + }, + { + "type": "~", + "named": false + }, + { + "type": "~=", + "named": false + } +] \ No newline at end of file diff --git a/grammars/pico-8-lua/src/parser.c b/grammars/pico-8-lua/src/parser.c new file mode 100644 index 0000000..5e0a04f --- /dev/null +++ b/grammars/pico-8-lua/src/parser.c @@ -0,0 +1,25033 @@ +#include "tree_sitter/parser.h" + +#if defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic ignored "-Wmissing-field-initializers" +#endif + +#define LANGUAGE_VERSION 14 +#define STATE_COUNT 490 +#define LARGE_STATE_COUNT 11 +#define SYMBOL_COUNT 171 +#define ALIAS_COUNT 0 +#define TOKEN_COUNT 99 +#define EXTERNAL_TOKEN_COUNT 6 +#define FIELD_COUNT 25 +#define MAX_ALIAS_SEQUENCE_LENGTH 7 +#define PRODUCTION_ID_COUNT 75 + +enum ts_symbol_identifiers { + sym_identifier = 1, + sym_hash_bang_line = 2, + anon_sym_return = 3, + anon_sym_SEMI = 4, + anon_sym_EQ = 5, + anon_sym_COMMA = 6, + anon_sym_PLUS_EQ = 7, + anon_sym_DASH_EQ = 8, + anon_sym_STAR_EQ = 9, + anon_sym_SLASH_EQ = 10, + anon_sym_PERCENT_EQ = 11, + anon_sym_BSLASH_EQ = 12, + anon_sym_CARET_EQ = 13, + anon_sym_DOT_DOT_EQ = 14, + anon_sym_AMP_EQ = 15, + anon_sym_PIPE_EQ = 16, + anon_sym_CARET_CARET_EQ = 17, + anon_sym_LT_LT_EQ = 18, + anon_sym_GT_GT_EQ = 19, + anon_sym_GT_GT_GT_EQ = 20, + anon_sym_LT_LT_GT_EQ = 21, + anon_sym_GT_GT_LT_EQ = 22, + anon_sym_COLON_COLON = 23, + sym_break_statement = 24, + anon_sym_goto = 25, + anon_sym_do = 26, + anon_sym_end = 27, + anon_sym_while = 28, + anon_sym_LPAREN = 29, + anon_sym_RPAREN = 30, + anon_sym_repeat = 31, + anon_sym_until = 32, + anon_sym_if = 33, + anon_sym_then = 34, + anon_sym_elseif = 35, + anon_sym_else = 36, + anon_sym_for = 37, + anon_sym_in = 38, + anon_sym_function = 39, + anon_sym_local = 40, + anon_sym_DOT = 41, + anon_sym_COLON = 42, + anon_sym_LT = 43, + anon_sym_GT = 44, + anon_sym_QMARK = 45, + aux_sym_include_statement_token1 = 46, + aux_sym_include_statement_token2 = 47, + sym_nil = 48, + sym_false = 49, + sym_true = 50, + sym_number = 51, + anon_sym_DQUOTE = 52, + anon_sym_SQUOTE = 53, + aux_sym__doublequote_string_content_token1 = 54, + aux_sym__singlequote_string_content_token1 = 55, + sym_escape_sequence = 56, + sym_vararg_expression = 57, + anon_sym_LBRACK = 58, + anon_sym_RBRACK = 59, + anon_sym_LBRACE = 60, + anon_sym_RBRACE = 61, + anon_sym_or = 62, + anon_sym_and = 63, + anon_sym_LT_EQ = 64, + anon_sym_EQ_EQ = 65, + anon_sym_TILDE_EQ = 66, + anon_sym_BANG_EQ = 67, + anon_sym_GT_EQ = 68, + anon_sym_PIPE = 69, + anon_sym_TILDE = 70, + anon_sym_CARET_CARET = 71, + anon_sym_AMP = 72, + anon_sym_LT_LT = 73, + anon_sym_GT_GT = 74, + anon_sym_GT_GT_GT = 75, + anon_sym_LT_LT_GT = 76, + anon_sym_GT_GT_LT = 77, + anon_sym_PLUS = 78, + anon_sym_DASH = 79, + anon_sym_STAR = 80, + anon_sym_SLASH = 81, + anon_sym_SLASH_SLASH = 82, + anon_sym_PERCENT = 83, + anon_sym_BSLASH = 84, + anon_sym_DOT_DOT = 85, + anon_sym_CARET = 86, + anon_sym_not = 87, + anon_sym_POUND = 88, + anon_sym_AT = 89, + anon_sym_DOLLAR = 90, + anon_sym_DASH_DASH = 91, + aux_sym_comment_token1 = 92, + sym__block_comment_start = 93, + sym__block_comment_content = 94, + sym__block_comment_end = 95, + sym__block_string_start = 96, + sym__block_string_content = 97, + sym__block_string_end = 98, + sym_chunk = 99, + sym__block = 100, + sym_statement = 101, + sym_return_statement = 102, + sym_empty_statement = 103, + sym_assignment_statement = 104, + sym__variable_assignment_varlist = 105, + sym__variable_assignment_explist = 106, + sym_compound_assignment_statement = 107, + sym_label_statement = 108, + sym_goto_statement = 109, + sym_do_statement = 110, + sym_while_statement = 111, + sym_shorthand_while_statement = 112, + sym_repeat_statement = 113, + sym_if_statement = 114, + sym_elseif_statement = 115, + sym_else_statement = 116, + sym_shorthand_if_statement = 117, + sym_for_statement = 118, + sym_for_generic_clause = 119, + sym_for_numeric_clause = 120, + sym__name_list = 121, + sym_declaration = 122, + sym_function_declaration = 123, + sym__local_function_declaration = 124, + sym__function_name = 125, + sym__function_name_prefix_expression = 126, + sym__function_name_dot_index_expression = 127, + sym__function_name_method_index_expression = 128, + sym_variable_declaration = 129, + sym__variable_assignment = 130, + sym__att_name_list = 131, + sym__attrib = 132, + sym__expression_list = 133, + sym_print_shorthand_statement = 134, + sym_include_statement = 135, + sym_expression = 136, + sym_string = 137, + sym__quote_string = 138, + aux_sym__doublequote_string_content = 139, + aux_sym__singlequote_string_content = 140, + sym__block_string = 141, + sym_function_definition = 142, + sym__function_body = 143, + sym_parameters = 144, + sym__parameter_list = 145, + sym__vararg_parameter = 146, + sym__prefix_expression = 147, + sym_variable = 148, + sym_bracket_index_expression = 149, + sym_dot_index_expression = 150, + sym_function_call = 151, + sym_method_index_expression = 152, + sym_arguments = 153, + sym_parenthesized_expression = 154, + sym_table_constructor = 155, + sym__field_list = 156, + sym__field_sep = 157, + sym_field = 158, + sym_binary_expression = 159, + sym_unary_expression = 160, + sym_comment = 161, + aux_sym_chunk_repeat1 = 162, + aux_sym__variable_assignment_varlist_repeat1 = 163, + aux_sym__variable_assignment_explist_repeat1 = 164, + aux_sym_if_statement_repeat1 = 165, + aux_sym__name_list_repeat1 = 166, + aux_sym__att_name_list_repeat1 = 167, + aux_sym__expression_list_repeat1 = 168, + aux_sym_print_shorthand_statement_repeat1 = 169, + aux_sym__field_list_repeat1 = 170, +}; + +static const char * const ts_symbol_names[] = { + [ts_builtin_sym_end] = "end", + [sym_identifier] = "identifier", + [sym_hash_bang_line] = "hash_bang_line", + [anon_sym_return] = "return", + [anon_sym_SEMI] = ";", + [anon_sym_EQ] = "=", + [anon_sym_COMMA] = ",", + [anon_sym_PLUS_EQ] = "+=", + [anon_sym_DASH_EQ] = "-=", + [anon_sym_STAR_EQ] = "*=", + [anon_sym_SLASH_EQ] = "/=", + [anon_sym_PERCENT_EQ] = "%=", + [anon_sym_BSLASH_EQ] = "\\=", + [anon_sym_CARET_EQ] = "^=", + [anon_sym_DOT_DOT_EQ] = "..=", + [anon_sym_AMP_EQ] = "&=", + [anon_sym_PIPE_EQ] = "|=", + [anon_sym_CARET_CARET_EQ] = "^^=", + [anon_sym_LT_LT_EQ] = "<<=", + [anon_sym_GT_GT_EQ] = ">>=", + [anon_sym_GT_GT_GT_EQ] = ">>>=", + [anon_sym_LT_LT_GT_EQ] = "<<>=", + [anon_sym_GT_GT_LT_EQ] = ">><=", + [anon_sym_COLON_COLON] = "::", + [sym_break_statement] = "break_statement", + [anon_sym_goto] = "goto", + [anon_sym_do] = "do", + [anon_sym_end] = "end", + [anon_sym_while] = "while", + [anon_sym_LPAREN] = "(", + [anon_sym_RPAREN] = ")", + [anon_sym_repeat] = "repeat", + [anon_sym_until] = "until", + [anon_sym_if] = "if", + [anon_sym_then] = "then", + [anon_sym_elseif] = "elseif", + [anon_sym_else] = "else", + [anon_sym_for] = "for", + [anon_sym_in] = "in", + [anon_sym_function] = "function", + [anon_sym_local] = "local", + [anon_sym_DOT] = ".", + [anon_sym_COLON] = ":", + [anon_sym_LT] = "<", + [anon_sym_GT] = ">", + [anon_sym_QMARK] = "\?", + [aux_sym_include_statement_token1] = "#include", + [aux_sym_include_statement_token2] = "include_path", + [sym_nil] = "nil", + [sym_false] = "false", + [sym_true] = "true", + [sym_number] = "number", + [anon_sym_DQUOTE] = "\"", + [anon_sym_SQUOTE] = "'", + [aux_sym__doublequote_string_content_token1] = "_doublequote_string_content_token1", + [aux_sym__singlequote_string_content_token1] = "_singlequote_string_content_token1", + [sym_escape_sequence] = "escape_sequence", + [sym_vararg_expression] = "vararg_expression", + [anon_sym_LBRACK] = "[", + [anon_sym_RBRACK] = "]", + [anon_sym_LBRACE] = "{", + [anon_sym_RBRACE] = "}", + [anon_sym_or] = "or", + [anon_sym_and] = "and", + [anon_sym_LT_EQ] = "<=", + [anon_sym_EQ_EQ] = "==", + [anon_sym_TILDE_EQ] = "~=", + [anon_sym_BANG_EQ] = "!=", + [anon_sym_GT_EQ] = ">=", + [anon_sym_PIPE] = "|", + [anon_sym_TILDE] = "~", + [anon_sym_CARET_CARET] = "^^", + [anon_sym_AMP] = "&", + [anon_sym_LT_LT] = "<<", + [anon_sym_GT_GT] = ">>", + [anon_sym_GT_GT_GT] = ">>>", + [anon_sym_LT_LT_GT] = "<<>", + [anon_sym_GT_GT_LT] = ">><", + [anon_sym_PLUS] = "+", + [anon_sym_DASH] = "-", + [anon_sym_STAR] = "*", + [anon_sym_SLASH] = "/", + [anon_sym_SLASH_SLASH] = "//", + [anon_sym_PERCENT] = "%", + [anon_sym_BSLASH] = "\\", + [anon_sym_DOT_DOT] = "..", + [anon_sym_CARET] = "^", + [anon_sym_not] = "not", + [anon_sym_POUND] = "#", + [anon_sym_AT] = "@", + [anon_sym_DOLLAR] = "$", + [anon_sym_DASH_DASH] = "--", + [aux_sym_comment_token1] = "comment_content", + [sym__block_comment_start] = "[[", + [sym__block_comment_content] = "comment_content", + [sym__block_comment_end] = "]]", + [sym__block_string_start] = "[[", + [sym__block_string_content] = "string_content", + [sym__block_string_end] = "]]", + [sym_chunk] = "chunk", + [sym__block] = "block", + [sym_statement] = "statement", + [sym_return_statement] = "return_statement", + [sym_empty_statement] = "empty_statement", + [sym_assignment_statement] = "assignment_statement", + [sym__variable_assignment_varlist] = "variable_list", + [sym__variable_assignment_explist] = "expression_list", + [sym_compound_assignment_statement] = "compound_assignment_statement", + [sym_label_statement] = "label_statement", + [sym_goto_statement] = "goto_statement", + [sym_do_statement] = "do_statement", + [sym_while_statement] = "while_statement", + [sym_shorthand_while_statement] = "shorthand_while_statement", + [sym_repeat_statement] = "repeat_statement", + [sym_if_statement] = "if_statement", + [sym_elseif_statement] = "elseif_statement", + [sym_else_statement] = "else_statement", + [sym_shorthand_if_statement] = "shorthand_if_statement", + [sym_for_statement] = "for_statement", + [sym_for_generic_clause] = "for_generic_clause", + [sym_for_numeric_clause] = "for_numeric_clause", + [sym__name_list] = "variable_list", + [sym_declaration] = "declaration", + [sym_function_declaration] = "function_declaration", + [sym__local_function_declaration] = "function_declaration", + [sym__function_name] = "_function_name", + [sym__function_name_prefix_expression] = "_function_name_prefix_expression", + [sym__function_name_dot_index_expression] = "dot_index_expression", + [sym__function_name_method_index_expression] = "method_index_expression", + [sym_variable_declaration] = "variable_declaration", + [sym__variable_assignment] = "assignment_statement", + [sym__att_name_list] = "variable_list", + [sym__attrib] = "attribute", + [sym__expression_list] = "expression_list", + [sym_print_shorthand_statement] = "print_shorthand_statement", + [sym_include_statement] = "include_statement", + [sym_expression] = "expression", + [sym_string] = "string", + [sym__quote_string] = "_quote_string", + [aux_sym__doublequote_string_content] = "_doublequote_string_content", + [aux_sym__singlequote_string_content] = "_singlequote_string_content", + [sym__block_string] = "_block_string", + [sym_function_definition] = "function_definition", + [sym__function_body] = "_function_body", + [sym_parameters] = "parameters", + [sym__parameter_list] = "_parameter_list", + [sym__vararg_parameter] = "_vararg_parameter", + [sym__prefix_expression] = "_prefix_expression", + [sym_variable] = "variable", + [sym_bracket_index_expression] = "bracket_index_expression", + [sym_dot_index_expression] = "dot_index_expression", + [sym_function_call] = "function_call", + [sym_method_index_expression] = "method_index_expression", + [sym_arguments] = "arguments", + [sym_parenthesized_expression] = "parenthesized_expression", + [sym_table_constructor] = "table_constructor", + [sym__field_list] = "_field_list", + [sym__field_sep] = "_field_sep", + [sym_field] = "field", + [sym_binary_expression] = "binary_expression", + [sym_unary_expression] = "unary_expression", + [sym_comment] = "comment", + [aux_sym_chunk_repeat1] = "chunk_repeat1", + [aux_sym__variable_assignment_varlist_repeat1] = "_variable_assignment_varlist_repeat1", + [aux_sym__variable_assignment_explist_repeat1] = "_variable_assignment_explist_repeat1", + [aux_sym_if_statement_repeat1] = "if_statement_repeat1", + [aux_sym__name_list_repeat1] = "_name_list_repeat1", + [aux_sym__att_name_list_repeat1] = "_att_name_list_repeat1", + [aux_sym__expression_list_repeat1] = "_expression_list_repeat1", + [aux_sym_print_shorthand_statement_repeat1] = "print_shorthand_statement_repeat1", + [aux_sym__field_list_repeat1] = "_field_list_repeat1", +}; + +static const TSSymbol ts_symbol_map[] = { + [ts_builtin_sym_end] = ts_builtin_sym_end, + [sym_identifier] = sym_identifier, + [sym_hash_bang_line] = sym_hash_bang_line, + [anon_sym_return] = anon_sym_return, + [anon_sym_SEMI] = anon_sym_SEMI, + [anon_sym_EQ] = anon_sym_EQ, + [anon_sym_COMMA] = anon_sym_COMMA, + [anon_sym_PLUS_EQ] = anon_sym_PLUS_EQ, + [anon_sym_DASH_EQ] = anon_sym_DASH_EQ, + [anon_sym_STAR_EQ] = anon_sym_STAR_EQ, + [anon_sym_SLASH_EQ] = anon_sym_SLASH_EQ, + [anon_sym_PERCENT_EQ] = anon_sym_PERCENT_EQ, + [anon_sym_BSLASH_EQ] = anon_sym_BSLASH_EQ, + [anon_sym_CARET_EQ] = anon_sym_CARET_EQ, + [anon_sym_DOT_DOT_EQ] = anon_sym_DOT_DOT_EQ, + [anon_sym_AMP_EQ] = anon_sym_AMP_EQ, + [anon_sym_PIPE_EQ] = anon_sym_PIPE_EQ, + [anon_sym_CARET_CARET_EQ] = anon_sym_CARET_CARET_EQ, + [anon_sym_LT_LT_EQ] = anon_sym_LT_LT_EQ, + [anon_sym_GT_GT_EQ] = anon_sym_GT_GT_EQ, + [anon_sym_GT_GT_GT_EQ] = anon_sym_GT_GT_GT_EQ, + [anon_sym_LT_LT_GT_EQ] = anon_sym_LT_LT_GT_EQ, + [anon_sym_GT_GT_LT_EQ] = anon_sym_GT_GT_LT_EQ, + [anon_sym_COLON_COLON] = anon_sym_COLON_COLON, + [sym_break_statement] = sym_break_statement, + [anon_sym_goto] = anon_sym_goto, + [anon_sym_do] = anon_sym_do, + [anon_sym_end] = anon_sym_end, + [anon_sym_while] = anon_sym_while, + [anon_sym_LPAREN] = anon_sym_LPAREN, + [anon_sym_RPAREN] = anon_sym_RPAREN, + [anon_sym_repeat] = anon_sym_repeat, + [anon_sym_until] = anon_sym_until, + [anon_sym_if] = anon_sym_if, + [anon_sym_then] = anon_sym_then, + [anon_sym_elseif] = anon_sym_elseif, + [anon_sym_else] = anon_sym_else, + [anon_sym_for] = anon_sym_for, + [anon_sym_in] = anon_sym_in, + [anon_sym_function] = anon_sym_function, + [anon_sym_local] = anon_sym_local, + [anon_sym_DOT] = anon_sym_DOT, + [anon_sym_COLON] = anon_sym_COLON, + [anon_sym_LT] = anon_sym_LT, + [anon_sym_GT] = anon_sym_GT, + [anon_sym_QMARK] = anon_sym_QMARK, + [aux_sym_include_statement_token1] = aux_sym_include_statement_token1, + [aux_sym_include_statement_token2] = aux_sym_include_statement_token2, + [sym_nil] = sym_nil, + [sym_false] = sym_false, + [sym_true] = sym_true, + [sym_number] = sym_number, + [anon_sym_DQUOTE] = anon_sym_DQUOTE, + [anon_sym_SQUOTE] = anon_sym_SQUOTE, + [aux_sym__doublequote_string_content_token1] = aux_sym__doublequote_string_content_token1, + [aux_sym__singlequote_string_content_token1] = aux_sym__singlequote_string_content_token1, + [sym_escape_sequence] = sym_escape_sequence, + [sym_vararg_expression] = sym_vararg_expression, + [anon_sym_LBRACK] = anon_sym_LBRACK, + [anon_sym_RBRACK] = anon_sym_RBRACK, + [anon_sym_LBRACE] = anon_sym_LBRACE, + [anon_sym_RBRACE] = anon_sym_RBRACE, + [anon_sym_or] = anon_sym_or, + [anon_sym_and] = anon_sym_and, + [anon_sym_LT_EQ] = anon_sym_LT_EQ, + [anon_sym_EQ_EQ] = anon_sym_EQ_EQ, + [anon_sym_TILDE_EQ] = anon_sym_TILDE_EQ, + [anon_sym_BANG_EQ] = anon_sym_BANG_EQ, + [anon_sym_GT_EQ] = anon_sym_GT_EQ, + [anon_sym_PIPE] = anon_sym_PIPE, + [anon_sym_TILDE] = anon_sym_TILDE, + [anon_sym_CARET_CARET] = anon_sym_CARET_CARET, + [anon_sym_AMP] = anon_sym_AMP, + [anon_sym_LT_LT] = anon_sym_LT_LT, + [anon_sym_GT_GT] = anon_sym_GT_GT, + [anon_sym_GT_GT_GT] = anon_sym_GT_GT_GT, + [anon_sym_LT_LT_GT] = anon_sym_LT_LT_GT, + [anon_sym_GT_GT_LT] = anon_sym_GT_GT_LT, + [anon_sym_PLUS] = anon_sym_PLUS, + [anon_sym_DASH] = anon_sym_DASH, + [anon_sym_STAR] = anon_sym_STAR, + [anon_sym_SLASH] = anon_sym_SLASH, + [anon_sym_SLASH_SLASH] = anon_sym_SLASH_SLASH, + [anon_sym_PERCENT] = anon_sym_PERCENT, + [anon_sym_BSLASH] = anon_sym_BSLASH, + [anon_sym_DOT_DOT] = anon_sym_DOT_DOT, + [anon_sym_CARET] = anon_sym_CARET, + [anon_sym_not] = anon_sym_not, + [anon_sym_POUND] = anon_sym_POUND, + [anon_sym_AT] = anon_sym_AT, + [anon_sym_DOLLAR] = anon_sym_DOLLAR, + [anon_sym_DASH_DASH] = anon_sym_DASH_DASH, + [aux_sym_comment_token1] = sym__block_comment_content, + [sym__block_comment_start] = sym__block_comment_start, + [sym__block_comment_content] = sym__block_comment_content, + [sym__block_comment_end] = sym__block_comment_end, + [sym__block_string_start] = sym__block_comment_start, + [sym__block_string_content] = sym__block_string_content, + [sym__block_string_end] = sym__block_comment_end, + [sym_chunk] = sym_chunk, + [sym__block] = sym__block, + [sym_statement] = sym_statement, + [sym_return_statement] = sym_return_statement, + [sym_empty_statement] = sym_empty_statement, + [sym_assignment_statement] = sym_assignment_statement, + [sym__variable_assignment_varlist] = sym__variable_assignment_varlist, + [sym__variable_assignment_explist] = sym__variable_assignment_explist, + [sym_compound_assignment_statement] = sym_compound_assignment_statement, + [sym_label_statement] = sym_label_statement, + [sym_goto_statement] = sym_goto_statement, + [sym_do_statement] = sym_do_statement, + [sym_while_statement] = sym_while_statement, + [sym_shorthand_while_statement] = sym_shorthand_while_statement, + [sym_repeat_statement] = sym_repeat_statement, + [sym_if_statement] = sym_if_statement, + [sym_elseif_statement] = sym_elseif_statement, + [sym_else_statement] = sym_else_statement, + [sym_shorthand_if_statement] = sym_shorthand_if_statement, + [sym_for_statement] = sym_for_statement, + [sym_for_generic_clause] = sym_for_generic_clause, + [sym_for_numeric_clause] = sym_for_numeric_clause, + [sym__name_list] = sym__variable_assignment_varlist, + [sym_declaration] = sym_declaration, + [sym_function_declaration] = sym_function_declaration, + [sym__local_function_declaration] = sym_function_declaration, + [sym__function_name] = sym__function_name, + [sym__function_name_prefix_expression] = sym__function_name_prefix_expression, + [sym__function_name_dot_index_expression] = sym_dot_index_expression, + [sym__function_name_method_index_expression] = sym_method_index_expression, + [sym_variable_declaration] = sym_variable_declaration, + [sym__variable_assignment] = sym_assignment_statement, + [sym__att_name_list] = sym__variable_assignment_varlist, + [sym__attrib] = sym__attrib, + [sym__expression_list] = sym__variable_assignment_explist, + [sym_print_shorthand_statement] = sym_print_shorthand_statement, + [sym_include_statement] = sym_include_statement, + [sym_expression] = sym_expression, + [sym_string] = sym_string, + [sym__quote_string] = sym__quote_string, + [aux_sym__doublequote_string_content] = aux_sym__doublequote_string_content, + [aux_sym__singlequote_string_content] = aux_sym__singlequote_string_content, + [sym__block_string] = sym__block_string, + [sym_function_definition] = sym_function_definition, + [sym__function_body] = sym__function_body, + [sym_parameters] = sym_parameters, + [sym__parameter_list] = sym__parameter_list, + [sym__vararg_parameter] = sym__vararg_parameter, + [sym__prefix_expression] = sym__prefix_expression, + [sym_variable] = sym_variable, + [sym_bracket_index_expression] = sym_bracket_index_expression, + [sym_dot_index_expression] = sym_dot_index_expression, + [sym_function_call] = sym_function_call, + [sym_method_index_expression] = sym_method_index_expression, + [sym_arguments] = sym_arguments, + [sym_parenthesized_expression] = sym_parenthesized_expression, + [sym_table_constructor] = sym_table_constructor, + [sym__field_list] = sym__field_list, + [sym__field_sep] = sym__field_sep, + [sym_field] = sym_field, + [sym_binary_expression] = sym_binary_expression, + [sym_unary_expression] = sym_unary_expression, + [sym_comment] = sym_comment, + [aux_sym_chunk_repeat1] = aux_sym_chunk_repeat1, + [aux_sym__variable_assignment_varlist_repeat1] = aux_sym__variable_assignment_varlist_repeat1, + [aux_sym__variable_assignment_explist_repeat1] = aux_sym__variable_assignment_explist_repeat1, + [aux_sym_if_statement_repeat1] = aux_sym_if_statement_repeat1, + [aux_sym__name_list_repeat1] = aux_sym__name_list_repeat1, + [aux_sym__att_name_list_repeat1] = aux_sym__att_name_list_repeat1, + [aux_sym__expression_list_repeat1] = aux_sym__expression_list_repeat1, + [aux_sym_print_shorthand_statement_repeat1] = aux_sym_print_shorthand_statement_repeat1, + [aux_sym__field_list_repeat1] = aux_sym__field_list_repeat1, +}; + +static const TSSymbolMetadata ts_symbol_metadata[] = { + [ts_builtin_sym_end] = { + .visible = false, + .named = true, + }, + [sym_identifier] = { + .visible = true, + .named = true, + }, + [sym_hash_bang_line] = { + .visible = true, + .named = true, + }, + [anon_sym_return] = { + .visible = true, + .named = false, + }, + [anon_sym_SEMI] = { + .visible = true, + .named = false, + }, + [anon_sym_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_COMMA] = { + .visible = true, + .named = false, + }, + [anon_sym_PLUS_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_DASH_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_STAR_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_SLASH_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_PERCENT_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_BSLASH_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_CARET_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_DOT_DOT_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_AMP_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_PIPE_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_CARET_CARET_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_LT_LT_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_GT_GT_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_GT_GT_GT_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_LT_LT_GT_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_GT_GT_LT_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_COLON_COLON] = { + .visible = true, + .named = false, + }, + [sym_break_statement] = { + .visible = true, + .named = true, + }, + [anon_sym_goto] = { + .visible = true, + .named = false, + }, + [anon_sym_do] = { + .visible = true, + .named = false, + }, + [anon_sym_end] = { + .visible = true, + .named = false, + }, + [anon_sym_while] = { + .visible = true, + .named = false, + }, + [anon_sym_LPAREN] = { + .visible = true, + .named = false, + }, + [anon_sym_RPAREN] = { + .visible = true, + .named = false, + }, + [anon_sym_repeat] = { + .visible = true, + .named = false, + }, + [anon_sym_until] = { + .visible = true, + .named = false, + }, + [anon_sym_if] = { + .visible = true, + .named = false, + }, + [anon_sym_then] = { + .visible = true, + .named = false, + }, + [anon_sym_elseif] = { + .visible = true, + .named = false, + }, + [anon_sym_else] = { + .visible = true, + .named = false, + }, + [anon_sym_for] = { + .visible = true, + .named = false, + }, + [anon_sym_in] = { + .visible = true, + .named = false, + }, + [anon_sym_function] = { + .visible = true, + .named = false, + }, + [anon_sym_local] = { + .visible = true, + .named = false, + }, + [anon_sym_DOT] = { + .visible = true, + .named = false, + }, + [anon_sym_COLON] = { + .visible = true, + .named = false, + }, + [anon_sym_LT] = { + .visible = true, + .named = false, + }, + [anon_sym_GT] = { + .visible = true, + .named = false, + }, + [anon_sym_QMARK] = { + .visible = true, + .named = false, + }, + [aux_sym_include_statement_token1] = { + .visible = true, + .named = false, + }, + [aux_sym_include_statement_token2] = { + .visible = true, + .named = true, + }, + [sym_nil] = { + .visible = true, + .named = true, + }, + [sym_false] = { + .visible = true, + .named = true, + }, + [sym_true] = { + .visible = true, + .named = true, + }, + [sym_number] = { + .visible = true, + .named = true, + }, + [anon_sym_DQUOTE] = { + .visible = true, + .named = false, + }, + [anon_sym_SQUOTE] = { + .visible = true, + .named = false, + }, + [aux_sym__doublequote_string_content_token1] = { + .visible = false, + .named = false, + }, + [aux_sym__singlequote_string_content_token1] = { + .visible = false, + .named = false, + }, + [sym_escape_sequence] = { + .visible = true, + .named = true, + }, + [sym_vararg_expression] = { + .visible = true, + .named = true, + }, + [anon_sym_LBRACK] = { + .visible = true, + .named = false, + }, + [anon_sym_RBRACK] = { + .visible = true, + .named = false, + }, + [anon_sym_LBRACE] = { + .visible = true, + .named = false, + }, + [anon_sym_RBRACE] = { + .visible = true, + .named = false, + }, + [anon_sym_or] = { + .visible = true, + .named = false, + }, + [anon_sym_and] = { + .visible = true, + .named = false, + }, + [anon_sym_LT_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_EQ_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_TILDE_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_BANG_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_GT_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_PIPE] = { + .visible = true, + .named = false, + }, + [anon_sym_TILDE] = { + .visible = true, + .named = false, + }, + [anon_sym_CARET_CARET] = { + .visible = true, + .named = false, + }, + [anon_sym_AMP] = { + .visible = true, + .named = false, + }, + [anon_sym_LT_LT] = { + .visible = true, + .named = false, + }, + [anon_sym_GT_GT] = { + .visible = true, + .named = false, + }, + [anon_sym_GT_GT_GT] = { + .visible = true, + .named = false, + }, + [anon_sym_LT_LT_GT] = { + .visible = true, + .named = false, + }, + [anon_sym_GT_GT_LT] = { + .visible = true, + .named = false, + }, + [anon_sym_PLUS] = { + .visible = true, + .named = false, + }, + [anon_sym_DASH] = { + .visible = true, + .named = false, + }, + [anon_sym_STAR] = { + .visible = true, + .named = false, + }, + [anon_sym_SLASH] = { + .visible = true, + .named = false, + }, + [anon_sym_SLASH_SLASH] = { + .visible = true, + .named = false, + }, + [anon_sym_PERCENT] = { + .visible = true, + .named = false, + }, + [anon_sym_BSLASH] = { + .visible = true, + .named = false, + }, + [anon_sym_DOT_DOT] = { + .visible = true, + .named = false, + }, + [anon_sym_CARET] = { + .visible = true, + .named = false, + }, + [anon_sym_not] = { + .visible = true, + .named = false, + }, + [anon_sym_POUND] = { + .visible = true, + .named = false, + }, + [anon_sym_AT] = { + .visible = true, + .named = false, + }, + [anon_sym_DOLLAR] = { + .visible = true, + .named = false, + }, + [anon_sym_DASH_DASH] = { + .visible = true, + .named = false, + }, + [aux_sym_comment_token1] = { + .visible = true, + .named = true, + }, + [sym__block_comment_start] = { + .visible = true, + .named = false, + }, + [sym__block_comment_content] = { + .visible = true, + .named = true, + }, + [sym__block_comment_end] = { + .visible = true, + .named = false, + }, + [sym__block_string_start] = { + .visible = true, + .named = false, + }, + [sym__block_string_content] = { + .visible = true, + .named = true, + }, + [sym__block_string_end] = { + .visible = true, + .named = false, + }, + [sym_chunk] = { + .visible = true, + .named = true, + }, + [sym__block] = { + .visible = true, + .named = true, + }, + [sym_statement] = { + .visible = false, + .named = true, + .supertype = true, + }, + [sym_return_statement] = { + .visible = true, + .named = true, + }, + [sym_empty_statement] = { + .visible = true, + .named = true, + }, + [sym_assignment_statement] = { + .visible = true, + .named = true, + }, + [sym__variable_assignment_varlist] = { + .visible = true, + .named = true, + }, + [sym__variable_assignment_explist] = { + .visible = true, + .named = true, + }, + [sym_compound_assignment_statement] = { + .visible = true, + .named = true, + }, + [sym_label_statement] = { + .visible = true, + .named = true, + }, + [sym_goto_statement] = { + .visible = true, + .named = true, + }, + [sym_do_statement] = { + .visible = true, + .named = true, + }, + [sym_while_statement] = { + .visible = true, + .named = true, + }, + [sym_shorthand_while_statement] = { + .visible = true, + .named = true, + }, + [sym_repeat_statement] = { + .visible = true, + .named = true, + }, + [sym_if_statement] = { + .visible = true, + .named = true, + }, + [sym_elseif_statement] = { + .visible = true, + .named = true, + }, + [sym_else_statement] = { + .visible = true, + .named = true, + }, + [sym_shorthand_if_statement] = { + .visible = true, + .named = true, + }, + [sym_for_statement] = { + .visible = true, + .named = true, + }, + [sym_for_generic_clause] = { + .visible = true, + .named = true, + }, + [sym_for_numeric_clause] = { + .visible = true, + .named = true, + }, + [sym__name_list] = { + .visible = true, + .named = true, + }, + [sym_declaration] = { + .visible = false, + .named = true, + .supertype = true, + }, + [sym_function_declaration] = { + .visible = true, + .named = true, + }, + [sym__local_function_declaration] = { + .visible = true, + .named = true, + }, + [sym__function_name] = { + .visible = false, + .named = true, + }, + [sym__function_name_prefix_expression] = { + .visible = false, + .named = true, + }, + [sym__function_name_dot_index_expression] = { + .visible = true, + .named = true, + }, + [sym__function_name_method_index_expression] = { + .visible = true, + .named = true, + }, + [sym_variable_declaration] = { + .visible = true, + .named = true, + }, + [sym__variable_assignment] = { + .visible = true, + .named = true, + }, + [sym__att_name_list] = { + .visible = true, + .named = true, + }, + [sym__attrib] = { + .visible = true, + .named = true, + }, + [sym__expression_list] = { + .visible = true, + .named = true, + }, + [sym_print_shorthand_statement] = { + .visible = true, + .named = true, + }, + [sym_include_statement] = { + .visible = true, + .named = true, + }, + [sym_expression] = { + .visible = false, + .named = true, + .supertype = true, + }, + [sym_string] = { + .visible = true, + .named = true, + }, + [sym__quote_string] = { + .visible = false, + .named = true, + }, + [aux_sym__doublequote_string_content] = { + .visible = false, + .named = false, + }, + [aux_sym__singlequote_string_content] = { + .visible = false, + .named = false, + }, + [sym__block_string] = { + .visible = false, + .named = true, + }, + [sym_function_definition] = { + .visible = true, + .named = true, + }, + [sym__function_body] = { + .visible = false, + .named = true, + }, + [sym_parameters] = { + .visible = true, + .named = true, + }, + [sym__parameter_list] = { + .visible = false, + .named = true, + }, + [sym__vararg_parameter] = { + .visible = false, + .named = true, + }, + [sym__prefix_expression] = { + .visible = false, + .named = true, + }, + [sym_variable] = { + .visible = false, + .named = true, + .supertype = true, + }, + [sym_bracket_index_expression] = { + .visible = true, + .named = true, + }, + [sym_dot_index_expression] = { + .visible = true, + .named = true, + }, + [sym_function_call] = { + .visible = true, + .named = true, + }, + [sym_method_index_expression] = { + .visible = true, + .named = true, + }, + [sym_arguments] = { + .visible = true, + .named = true, + }, + [sym_parenthesized_expression] = { + .visible = true, + .named = true, + }, + [sym_table_constructor] = { + .visible = true, + .named = true, + }, + [sym__field_list] = { + .visible = false, + .named = true, + }, + [sym__field_sep] = { + .visible = false, + .named = true, + }, + [sym_field] = { + .visible = true, + .named = true, + }, + [sym_binary_expression] = { + .visible = true, + .named = true, + }, + [sym_unary_expression] = { + .visible = true, + .named = true, + }, + [sym_comment] = { + .visible = true, + .named = true, + }, + [aux_sym_chunk_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym__variable_assignment_varlist_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym__variable_assignment_explist_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_if_statement_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym__name_list_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym__att_name_list_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym__expression_list_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_print_shorthand_statement_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym__field_list_repeat1] = { + .visible = false, + .named = false, + }, +}; + +enum ts_field_identifiers { + field_alternative = 1, + field_argument = 2, + field_arguments = 3, + field_attribute = 4, + field_body = 5, + field_clause = 6, + field_condition = 7, + field_consequence = 8, + field_content = 9, + field_directive = 10, + field_end = 11, + field_field = 12, + field_left = 13, + field_local_declaration = 14, + field_method = 15, + field_name = 16, + field_operand = 17, + field_operator = 18, + field_parameters = 19, + field_path = 20, + field_right = 21, + field_start = 22, + field_step = 23, + field_table = 24, + field_value = 25, +}; + +static const char * const ts_field_names[] = { + [0] = NULL, + [field_alternative] = "alternative", + [field_argument] = "argument", + [field_arguments] = "arguments", + [field_attribute] = "attribute", + [field_body] = "body", + [field_clause] = "clause", + [field_condition] = "condition", + [field_consequence] = "consequence", + [field_content] = "content", + [field_directive] = "directive", + [field_end] = "end", + [field_field] = "field", + [field_left] = "left", + [field_local_declaration] = "local_declaration", + [field_method] = "method", + [field_name] = "name", + [field_operand] = "operand", + [field_operator] = "operator", + [field_parameters] = "parameters", + [field_path] = "path", + [field_right] = "right", + [field_start] = "start", + [field_step] = "step", + [field_table] = "table", + [field_value] = "value", +}; + +static const TSFieldMapSlice ts_field_map_slices[PRODUCTION_ID_COUNT] = { + [1] = {.index = 0, .length = 1}, + [2] = {.index = 1, .length = 4}, + [3] = {.index = 5, .length = 1}, + [4] = {.index = 6, .length = 1}, + [5] = {.index = 7, .length = 2}, + [6] = {.index = 9, .length = 3}, + [7] = {.index = 12, .length = 2}, + [8] = {.index = 14, .length = 2}, + [9] = {.index = 16, .length = 1}, + [10] = {.index = 17, .length = 2}, + [11] = {.index = 19, .length = 2}, + [12] = {.index = 21, .length = 2}, + [13] = {.index = 23, .length = 2}, + [14] = {.index = 25, .length = 2}, + [15] = {.index = 27, .length = 3}, + [16] = {.index = 30, .length = 2}, + [17] = {.index = 32, .length = 2}, + [18] = {.index = 34, .length = 1}, + [19] = {.index = 35, .length = 2}, + [20] = {.index = 37, .length = 1}, + [21] = {.index = 38, .length = 1}, + [22] = {.index = 39, .length = 3}, + [23] = {.index = 42, .length = 2}, + [24] = {.index = 44, .length = 3}, + [25] = {.index = 47, .length = 2}, + [26] = {.index = 49, .length = 3}, + [27] = {.index = 52, .length = 3}, + [28] = {.index = 55, .length = 2}, + [29] = {.index = 57, .length = 2}, + [30] = {.index = 59, .length = 1}, + [31] = {.index = 60, .length = 3}, + [32] = {.index = 63, .length = 2}, + [33] = {.index = 65, .length = 1}, + [34] = {.index = 66, .length = 1}, + [35] = {.index = 27, .length = 3}, + [36] = {.index = 67, .length = 3}, + [37] = {.index = 70, .length = 1}, + [38] = {.index = 71, .length = 2}, + [39] = {.index = 73, .length = 1}, + [40] = {.index = 74, .length = 1}, + [41] = {.index = 75, .length = 3}, + [42] = {.index = 78, .length = 4}, + [43] = {.index = 82, .length = 4}, + [44] = {.index = 86, .length = 4}, + [45] = {.index = 90, .length = 3}, + [46] = {.index = 93, .length = 4}, + [47] = {.index = 97, .length = 1}, + [48] = {.index = 98, .length = 2}, + [49] = {.index = 100, .length = 2}, + [50] = {.index = 102, .length = 1}, + [51] = {.index = 103, .length = 2}, + [52] = {.index = 105, .length = 2}, + [53] = {.index = 107, .length = 2}, + [54] = {.index = 109, .length = 2}, + [55] = {.index = 111, .length = 2}, + [56] = {.index = 113, .length = 2}, + [57] = {.index = 115, .length = 2}, + [58] = {.index = 117, .length = 2}, + [59] = {.index = 119, .length = 2}, + [60] = {.index = 121, .length = 2}, + [61] = {.index = 123, .length = 2}, + [62] = {.index = 125, .length = 5}, + [63] = {.index = 130, .length = 1}, + [64] = {.index = 131, .length = 2}, + [65] = {.index = 133, .length = 2}, + [66] = {.index = 135, .length = 3}, + [67] = {.index = 138, .length = 3}, + [68] = {.index = 141, .length = 3}, + [69] = {.index = 144, .length = 4}, + [70] = {.index = 148, .length = 3}, + [71] = {.index = 151, .length = 3}, + [72] = {.index = 154, .length = 3}, + [73] = {.index = 157, .length = 4}, + [74] = {.index = 161, .length = 5}, +}; + +static const TSFieldMapEntry ts_field_map_entries[] = { + [0] = + {field_local_declaration, 0, .inherited = true}, + [1] = + {field_body, 0, .inherited = true}, + {field_local_declaration, 0}, + {field_name, 0, .inherited = true}, + {field_parameters, 0, .inherited = true}, + [5] = + {field_local_declaration, 0}, + [6] = + {field_name, 0}, + [7] = + {field_content, 1}, + {field_start, 0}, + [9] = + {field_content, 0, .inherited = true}, + {field_end, 0, .inherited = true}, + {field_start, 0, .inherited = true}, + [12] = + {field_field, 0, .inherited = true}, + {field_table, 0, .inherited = true}, + [14] = + {field_method, 0, .inherited = true}, + {field_table, 0, .inherited = true}, + [16] = + {field_operator, 1, .inherited = true}, + [17] = + {field_attribute, 1, .inherited = true}, + {field_name, 1, .inherited = true}, + [19] = + {field_argument, 1}, + {field_directive, 0}, + [21] = + {field_directive, 0}, + {field_path, 1}, + [23] = + {field_arguments, 1}, + {field_name, 0}, + [25] = + {field_name, 0}, + {field_name, 1, .inherited = true}, + [27] = + {field_content, 1}, + {field_end, 2}, + {field_start, 0}, + [30] = + {field_body, 1, .inherited = true}, + {field_parameters, 1, .inherited = true}, + [32] = + {field_end, 1}, + {field_start, 0}, + [34] = + {field_value, 0}, + [35] = + {field_operand, 1}, + {field_operator, 0}, + [37] = + {field_body, 1}, + [38] = + {field_condition, 2}, + [39] = + {field_body, 2, .inherited = true}, + {field_name, 1}, + {field_parameters, 2, .inherited = true}, + [42] = + {field_attribute, 1}, + {field_name, 0}, + [44] = + {field_attribute, 1, .inherited = true}, + {field_name, 0}, + {field_name, 1, .inherited = true}, + [47] = + {field_attribute, 0}, + {field_name, 1}, + [49] = + {field_argument, 1}, + {field_argument, 2, .inherited = true}, + {field_directive, 0}, + [52] = + {field_name, 0, .inherited = true}, + {field_operator, 1}, + {field_value, 2, .inherited = true}, + [55] = + {field_field, 2}, + {field_table, 0}, + [57] = + {field_method, 2}, + {field_table, 0}, + [59] = + {field_name, 1}, + [60] = + {field_name, 0}, + {field_operator, 1}, + {field_value, 2}, + [63] = + {field_name, 0, .inherited = true}, + {field_name, 1, .inherited = true}, + [65] = + {field_name, 0, .inherited = true}, + [66] = + {field_parameters, 0}, + [67] = + {field_left, 0}, + {field_operator, 1}, + {field_right, 2}, + [70] = + {field_condition, 1}, + [71] = + {field_body, 1}, + {field_condition, 3}, + [73] = + {field_alternative, 0}, + [74] = + {field_clause, 1}, + [75] = + {field_body, 3, .inherited = true}, + {field_name, 2}, + {field_parameters, 3, .inherited = true}, + [78] = + {field_attribute, 1}, + {field_attribute, 2, .inherited = true}, + {field_name, 0}, + {field_name, 2, .inherited = true}, + [82] = + {field_attribute, 0, .inherited = true}, + {field_attribute, 1, .inherited = true}, + {field_name, 0, .inherited = true}, + {field_name, 1, .inherited = true}, + [86] = + {field_attribute, 0, .inherited = true}, + {field_name, 0, .inherited = true}, + {field_operator, 1}, + {field_value, 2, .inherited = true}, + [90] = + {field_attribute, 0}, + {field_attribute, 2}, + {field_name, 1}, + [93] = + {field_attribute, 0}, + {field_attribute, 2, .inherited = true}, + {field_name, 1}, + {field_name, 2, .inherited = true}, + [97] = + {field_argument, 1}, + [98] = + {field_argument, 0, .inherited = true}, + {field_argument, 1, .inherited = true}, + [100] = + {field_value, 0}, + {field_value, 1, .inherited = true}, + [102] = + {field_name, 1, .inherited = true}, + [103] = + {field_body, 1}, + {field_parameters, 0}, + [105] = + {field_name, 0}, + {field_value, 2}, + [107] = + {field_body, 4}, + {field_condition, 2}, + [109] = + {field_body, 3}, + {field_condition, 1}, + [111] = + {field_condition, 2}, + {field_consequence, 4}, + [113] = + {field_condition, 1}, + {field_consequence, 3}, + [115] = + {field_alternative, 3}, + {field_condition, 1}, + [117] = + {field_alternative, 3, .inherited = true}, + {field_condition, 1}, + [119] = + {field_alternative, 0, .inherited = true}, + {field_alternative, 1, .inherited = true}, + [121] = + {field_body, 3}, + {field_clause, 1}, + [123] = + {field_attribute, 2}, + {field_name, 1}, + [125] = + {field_attribute, 0}, + {field_attribute, 2}, + {field_attribute, 3, .inherited = true}, + {field_name, 1}, + {field_name, 3, .inherited = true}, + [130] = + {field_value, 1}, + [131] = + {field_value, 0, .inherited = true}, + {field_value, 1, .inherited = true}, + [133] = + {field_name, 0}, + {field_name, 2, .inherited = true}, + [135] = + {field_alternative, 4}, + {field_condition, 1}, + {field_consequence, 3}, + [138] = + {field_alternative, 4, .inherited = true}, + {field_condition, 1}, + {field_consequence, 3}, + [141] = + {field_alternative, 3, .inherited = true}, + {field_alternative, 4}, + {field_condition, 1}, + [144] = + {field_end, 4}, + {field_name, 0}, + {field_operator, 1}, + {field_start, 2}, + [148] = + {field_name, 0}, + {field_name, 1, .inherited = true}, + {field_name, 3, .inherited = true}, + [151] = + {field_name, 1}, + {field_operator, 3}, + {field_value, 4}, + [154] = + {field_alternative, 6}, + {field_condition, 2}, + {field_consequence, 4}, + [157] = + {field_alternative, 4, .inherited = true}, + {field_alternative, 5}, + {field_condition, 1}, + {field_consequence, 3}, + [161] = + {field_end, 4}, + {field_name, 0}, + {field_operator, 1}, + {field_start, 2}, + {field_step, 6}, +}; + +static const TSSymbol ts_alias_sequences[PRODUCTION_ID_COUNT][MAX_ALIAS_SEQUENCE_LENGTH] = { + [0] = {0}, + [35] = { + [1] = sym__block_string_content, + }, +}; + +static const uint16_t ts_non_terminal_alias_map[] = { + aux_sym__doublequote_string_content, 2, + aux_sym__doublequote_string_content, + sym__block_string_content, + aux_sym__singlequote_string_content, 2, + aux_sym__singlequote_string_content, + sym__block_string_content, + 0, +}; + +static const TSStateId ts_primary_state_ids[STATE_COUNT] = { + [0] = 0, + [1] = 1, + [2] = 2, + [3] = 3, + [4] = 4, + [5] = 5, + [6] = 4, + [7] = 4, + [8] = 8, + [9] = 8, + [10] = 8, + [11] = 11, + [12] = 12, + [13] = 13, + [14] = 14, + [15] = 15, + [16] = 16, + [17] = 17, + [18] = 18, + [19] = 19, + [20] = 20, + [21] = 21, + [22] = 22, + [23] = 23, + [24] = 24, + [25] = 17, + [26] = 20, + [27] = 2, + [28] = 14, + [29] = 12, + [30] = 11, + [31] = 15, + [32] = 13, + [33] = 3, + [34] = 16, + [35] = 5, + [36] = 24, + [37] = 22, + [38] = 21, + [39] = 23, + [40] = 18, + [41] = 19, + [42] = 42, + [43] = 43, + [44] = 44, + [45] = 18, + [46] = 46, + [47] = 47, + [48] = 48, + [49] = 21, + [50] = 22, + [51] = 51, + [52] = 52, + [53] = 19, + [54] = 20, + [55] = 55, + [56] = 56, + [57] = 57, + [58] = 17, + [59] = 23, + [60] = 60, + [61] = 61, + [62] = 62, + [63] = 63, + [64] = 64, + [65] = 65, + [66] = 65, + [67] = 67, + [68] = 68, + [69] = 67, + [70] = 68, + [71] = 71, + [72] = 72, + [73] = 73, + [74] = 74, + [75] = 75, + [76] = 51, + [77] = 61, + [78] = 78, + [79] = 79, + [80] = 52, + [81] = 55, + [82] = 56, + [83] = 62, + [84] = 64, + [85] = 42, + [86] = 43, + [87] = 63, + [88] = 46, + [89] = 48, + [90] = 47, + [91] = 44, + [92] = 72, + [93] = 60, + [94] = 71, + [95] = 22, + [96] = 21, + [97] = 17, + [98] = 23, + [99] = 18, + [100] = 19, + [101] = 20, + [102] = 57, + [103] = 78, + [104] = 104, + [105] = 105, + [106] = 79, + [107] = 107, + [108] = 75, + [109] = 109, + [110] = 110, + [111] = 74, + [112] = 112, + [113] = 105, + [114] = 114, + [115] = 107, + [116] = 112, + [117] = 114, + [118] = 104, + [119] = 110, + [120] = 120, + [121] = 121, + [122] = 122, + [123] = 123, + [124] = 123, + [125] = 123, + [126] = 126, + [127] = 127, + [128] = 128, + [129] = 128, + [130] = 128, + [131] = 128, + [132] = 132, + [133] = 133, + [134] = 134, + [135] = 135, + [136] = 136, + [137] = 137, + [138] = 138, + [139] = 138, + [140] = 140, + [141] = 141, + [142] = 140, + [143] = 137, + [144] = 144, + [145] = 145, + [146] = 145, + [147] = 147, + [148] = 148, + [149] = 149, + [150] = 150, + [151] = 151, + [152] = 152, + [153] = 153, + [154] = 154, + [155] = 155, + [156] = 156, + [157] = 157, + [158] = 158, + [159] = 159, + [160] = 160, + [161] = 161, + [162] = 162, + [163] = 163, + [164] = 164, + [165] = 165, + [166] = 166, + [167] = 150, + [168] = 151, + [169] = 152, + [170] = 153, + [171] = 154, + [172] = 155, + [173] = 144, + [174] = 156, + [175] = 158, + [176] = 159, + [177] = 177, + [178] = 178, + [179] = 178, + [180] = 162, + [181] = 181, + [182] = 182, + [183] = 183, + [184] = 184, + [185] = 185, + [186] = 148, + [187] = 187, + [188] = 188, + [189] = 184, + [190] = 181, + [191] = 149, + [192] = 165, + [193] = 188, + [194] = 163, + [195] = 195, + [196] = 147, + [197] = 195, + [198] = 164, + [199] = 147, + [200] = 165, + [201] = 149, + [202] = 195, + [203] = 157, + [204] = 204, + [205] = 205, + [206] = 206, + [207] = 206, + [208] = 208, + [209] = 209, + [210] = 210, + [211] = 211, + [212] = 212, + [213] = 210, + [214] = 211, + [215] = 215, + [216] = 216, + [217] = 217, + [218] = 215, + [219] = 219, + [220] = 211, + [221] = 221, + [222] = 210, + [223] = 223, + [224] = 219, + [225] = 216, + [226] = 226, + [227] = 227, + [228] = 223, + [229] = 229, + [230] = 229, + [231] = 227, + [232] = 232, + [233] = 233, + [234] = 234, + [235] = 233, + [236] = 232, + [237] = 237, + [238] = 238, + [239] = 239, + [240] = 234, + [241] = 241, + [242] = 242, + [243] = 243, + [244] = 244, + [245] = 245, + [246] = 237, + [247] = 247, + [248] = 238, + [249] = 241, + [250] = 244, + [251] = 242, + [252] = 252, + [253] = 253, + [254] = 254, + [255] = 255, + [256] = 239, + [257] = 243, + [258] = 254, + [259] = 259, + [260] = 253, + [261] = 245, + [262] = 252, + [263] = 247, + [264] = 255, + [265] = 265, + [266] = 266, + [267] = 267, + [268] = 268, + [269] = 259, + [270] = 270, + [271] = 271, + [272] = 272, + [273] = 273, + [274] = 274, + [275] = 275, + [276] = 276, + [277] = 277, + [278] = 278, + [279] = 279, + [280] = 280, + [281] = 281, + [282] = 282, + [283] = 283, + [284] = 284, + [285] = 285, + [286] = 286, + [287] = 287, + [288] = 288, + [289] = 289, + [290] = 290, + [291] = 291, + [292] = 292, + [293] = 293, + [294] = 294, + [295] = 295, + [296] = 296, + [297] = 297, + [298] = 284, + [299] = 271, + [300] = 277, + [301] = 278, + [302] = 280, + [303] = 281, + [304] = 275, + [305] = 273, + [306] = 285, + [307] = 287, + [308] = 265, + [309] = 288, + [310] = 289, + [311] = 292, + [312] = 296, + [313] = 297, + [314] = 279, + [315] = 266, + [316] = 267, + [317] = 293, + [318] = 294, + [319] = 295, + [320] = 320, + [321] = 320, + [322] = 290, + [323] = 291, + [324] = 268, + [325] = 270, + [326] = 272, + [327] = 282, + [328] = 283, + [329] = 276, + [330] = 320, + [331] = 331, + [332] = 332, + [333] = 333, + [334] = 333, + [335] = 333, + [336] = 336, + [337] = 337, + [338] = 338, + [339] = 336, + [340] = 340, + [341] = 341, + [342] = 342, + [343] = 343, + [344] = 344, + [345] = 345, + [346] = 346, + [347] = 343, + [348] = 346, + [349] = 344, + [350] = 350, + [351] = 350, + [352] = 352, + [353] = 353, + [354] = 354, + [355] = 355, + [356] = 356, + [357] = 357, + [358] = 358, + [359] = 359, + [360] = 356, + [361] = 361, + [362] = 362, + [363] = 363, + [364] = 364, + [365] = 363, + [366] = 366, + [367] = 367, + [368] = 368, + [369] = 369, + [370] = 370, + [371] = 371, + [372] = 367, + [373] = 362, + [374] = 363, + [375] = 371, + [376] = 367, + [377] = 362, + [378] = 363, + [379] = 371, + [380] = 367, + [381] = 381, + [382] = 382, + [383] = 371, + [384] = 370, + [385] = 362, + [386] = 386, + [387] = 387, + [388] = 388, + [389] = 389, + [390] = 390, + [391] = 391, + [392] = 392, + [393] = 393, + [394] = 394, + [395] = 395, + [396] = 396, + [397] = 397, + [398] = 386, + [399] = 394, + [400] = 400, + [401] = 388, + [402] = 402, + [403] = 403, + [404] = 397, + [405] = 405, + [406] = 406, + [407] = 407, + [408] = 408, + [409] = 409, + [410] = 410, + [411] = 411, + [412] = 412, + [413] = 413, + [414] = 414, + [415] = 415, + [416] = 416, + [417] = 417, + [418] = 418, + [419] = 419, + [420] = 420, + [421] = 421, + [422] = 422, + [423] = 423, + [424] = 424, + [425] = 425, + [426] = 426, + [427] = 427, + [428] = 428, + [429] = 429, + [430] = 423, + [431] = 431, + [432] = 432, + [433] = 433, + [434] = 434, + [435] = 435, + [436] = 436, + [437] = 437, + [438] = 438, + [439] = 439, + [440] = 440, + [441] = 427, + [442] = 442, + [443] = 443, + [444] = 444, + [445] = 445, + [446] = 446, + [447] = 447, + [448] = 419, + [449] = 449, + [450] = 440, + [451] = 422, + [452] = 422, + [453] = 453, + [454] = 443, + [455] = 419, + [456] = 456, + [457] = 457, + [458] = 422, + [459] = 431, + [460] = 460, + [461] = 433, + [462] = 412, + [463] = 463, + [464] = 419, + [465] = 465, + [466] = 412, + [467] = 415, + [468] = 424, + [469] = 445, + [470] = 418, + [471] = 449, + [472] = 416, + [473] = 412, + [474] = 474, + [475] = 475, + [476] = 436, + [477] = 438, + [478] = 420, + [479] = 414, + [480] = 439, + [481] = 481, + [482] = 429, + [483] = 483, + [484] = 444, + [485] = 434, + [486] = 428, + [487] = 487, + [488] = 488, + [489] = 489, +}; + +static TSCharacterRange sym_escape_sequence_character_set_1[] = { + {'\n', '\n'}, {'"', '"'}, {'\'', '\''}, {'0', '9'}, {'\\', '\\'}, {'a', 'b'}, {'f', 'f'}, {'n', 'n'}, + {'r', 'r'}, {'t', 'v'}, {'x', 'x'}, {'z', 'z'}, +}; + +static bool ts_lex(TSLexer *lexer, TSStateId state) { + START_LEXER(); + eof = lexer->eof(lexer); + switch (state) { + case 0: + if (eof) ADVANCE(48); + ADVANCE_MAP( + '!', 11, + '"', 96, + '#', 154, + '$', 156, + '%', 146, + '&', 125, + '\'', 97, + '(', 71, + ')', 72, + '*', 141, + '+', 137, + ',', 53, + '-', 139, + '.', 74, + '/', 143, + '0', 89, + ':', 78, + ';', 50, + '<', 79, + '=', 52, + '>', 82, + '?', 84, + '@', 155, + '[', 109, + '\\', 148, + ']', 110, + '^', 151, + '{', 111, + '|', 119, + '}', 112, + '~', 121, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(0); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(90); + if (lookahead > '@' && + (lookahead < '{' || 0x9f < lookahead)) ADVANCE(157); + END_STATE(); + case 1: + if (lookahead == '!') ADVANCE(49); + if (lookahead == 'i') ADVANCE(32); + END_STATE(); + case 2: + ADVANCE_MAP( + '"', 96, + '%', 12, + '&', 13, + '\'', 97, + '(', 71, + '*', 14, + '+', 15, + ',', 53, + '-', 5, + '.', 76, + '/', 16, + ':', 77, + '<', 9, + '=', 51, + '>', 26, + '[', 109, + '\\', 17, + '^', 18, + '{', 111, + '|', 19, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(2); + END_STATE(); + case 3: + if (lookahead == '"') ADVANCE(96); + if (lookahead == '-') ADVANCE(99); + if (lookahead == '\\') ADVANCE(34); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(98); + if (lookahead != 0) ADVANCE(100); + END_STATE(); + case 4: + if (lookahead == '\'') ADVANCE(97); + if (lookahead == '-') ADVANCE(102); + if (lookahead == '\\') ADVANCE(34); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(101); + if (lookahead != 0) ADVANCE(103); + END_STATE(); + case 5: + if (lookahead == '-') ADVANCE(158); + if (lookahead == '=') ADVANCE(55); + END_STATE(); + case 6: + if (lookahead == '.') ADVANCE(41); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(91); + END_STATE(); + case 7: + if (lookahead == '.') ADVANCE(8); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(92); + END_STATE(); + case 8: + if (lookahead == '.') ADVANCE(108); + END_STATE(); + case 9: + if (lookahead == '<') ADVANCE(21); + END_STATE(); + case 10: + if (lookahead == '<') ADVANCE(24); + if (lookahead == '=') ADVANCE(66); + if (lookahead == '>') ADVANCE(25); + END_STATE(); + case 11: + if (lookahead == '=') ADVANCE(116); + END_STATE(); + case 12: + if (lookahead == '=') ADVANCE(58); + END_STATE(); + case 13: + if (lookahead == '=') ADVANCE(62); + END_STATE(); + case 14: + if (lookahead == '=') ADVANCE(56); + END_STATE(); + case 15: + if (lookahead == '=') ADVANCE(54); + END_STATE(); + case 16: + if (lookahead == '=') ADVANCE(57); + END_STATE(); + case 17: + if (lookahead == '=') ADVANCE(59); + END_STATE(); + case 18: + if (lookahead == '=') ADVANCE(60); + if (lookahead == '^') ADVANCE(22); + END_STATE(); + case 19: + if (lookahead == '=') ADVANCE(63); + END_STATE(); + case 20: + if (lookahead == '=') ADVANCE(61); + END_STATE(); + case 21: + if (lookahead == '=') ADVANCE(65); + if (lookahead == '>') ADVANCE(23); + END_STATE(); + case 22: + if (lookahead == '=') ADVANCE(64); + END_STATE(); + case 23: + if (lookahead == '=') ADVANCE(68); + END_STATE(); + case 24: + if (lookahead == '=') ADVANCE(69); + END_STATE(); + case 25: + if (lookahead == '=') ADVANCE(67); + END_STATE(); + case 26: + if (lookahead == '>') ADVANCE(10); + END_STATE(); + case 27: + if (lookahead == 'c') ADVANCE(31); + END_STATE(); + case 28: + if (lookahead == 'd') ADVANCE(29); + END_STATE(); + case 29: + if (lookahead == 'e') ADVANCE(37); + END_STATE(); + case 30: + if (lookahead == 'i') ADVANCE(32); + END_STATE(); + case 31: + if (lookahead == 'l') ADVANCE(33); + END_STATE(); + case 32: + if (lookahead == 'n') ADVANCE(27); + END_STATE(); + case 33: + if (lookahead == 'u') ADVANCE(28); + END_STATE(); + case 34: + if (lookahead == 'u') ADVANCE(35); + if (lookahead == 'x') ADVANCE(44); + if (lookahead == 'z') ADVANCE(105); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(107); + if (set_contains(sym_escape_sequence_character_set_1, 12, lookahead)) ADVANCE(104); + END_STATE(); + case 35: + if (lookahead == '{') ADVANCE(43); + END_STATE(); + case 36: + if (lookahead == '}') ADVANCE(104); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(36); + END_STATE(); + case 37: + if (lookahead == '\t' || + lookahead == ' ') ADVANCE(85); + END_STATE(); + case 38: + if (lookahead == '+' || + lookahead == '-') ADVANCE(40); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(95); + END_STATE(); + case 39: + if (lookahead == '0' || + lookahead == '1') ADVANCE(94); + END_STATE(); + case 40: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(95); + END_STATE(); + case 41: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(93); + END_STATE(); + case 42: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(104); + END_STATE(); + case 43: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(36); + END_STATE(); + case 44: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(42); + END_STATE(); + case 45: + if (eof) ADVANCE(48); + ADVANCE_MAP( + '!', 11, + '"', 96, + '#', 1, + '%', 146, + '&', 125, + '\'', 97, + '(', 71, + ')', 72, + '*', 141, + '+', 137, + ',', 53, + '-', 139, + '.', 73, + '/', 143, + ':', 78, + ';', 50, + '<', 79, + '=', 52, + '>', 82, + '?', 84, + '[', 109, + '\\', 148, + ']', 110, + '^', 151, + '{', 111, + '|', 119, + '}', 112, + '~', 121, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(45); + if (lookahead > '@' && + (lookahead < '{' || 0x9f < lookahead)) ADVANCE(157); + END_STATE(); + case 46: + if (eof) ADVANCE(48); + ADVANCE_MAP( + '!', 11, + '"', 96, + '#', 30, + '%', 145, + '&', 124, + '\'', 97, + '(', 71, + ')', 72, + '*', 140, + '+', 136, + ',', 53, + '-', 138, + '.', 75, + '/', 142, + ':', 78, + ';', 50, + '<', 80, + '=', 52, + '>', 83, + '?', 84, + '[', 109, + '\\', 147, + ']', 110, + '^', 152, + '{', 111, + '|', 118, + '}', 112, + '~', 121, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(46); + if (lookahead > '@' && + (lookahead < '{' || 0x9f < lookahead)) ADVANCE(157); + END_STATE(); + case 47: + if (eof) ADVANCE(48); + ADVANCE_MAP( + '"', 96, + '#', 153, + '$', 156, + '%', 145, + '\'', 97, + '(', 71, + ')', 72, + '-', 138, + '.', 7, + '0', 89, + ';', 50, + '>', 81, + '@', 155, + '[', 109, + '{', 111, + '}', 112, + '~', 120, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(47); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(90); + if (lookahead > '@' && + (lookahead < '[' || '^' < lookahead) && + (lookahead < '{' || 0x9f < lookahead)) ADVANCE(157); + END_STATE(); + case 48: + ACCEPT_TOKEN(ts_builtin_sym_end); + END_STATE(); + case 49: + ACCEPT_TOKEN(sym_hash_bang_line); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(49); + END_STATE(); + case 50: + ACCEPT_TOKEN(anon_sym_SEMI); + END_STATE(); + case 51: + ACCEPT_TOKEN(anon_sym_EQ); + END_STATE(); + case 52: + ACCEPT_TOKEN(anon_sym_EQ); + if (lookahead == '=') ADVANCE(114); + END_STATE(); + case 53: + ACCEPT_TOKEN(anon_sym_COMMA); + END_STATE(); + case 54: + ACCEPT_TOKEN(anon_sym_PLUS_EQ); + END_STATE(); + case 55: + ACCEPT_TOKEN(anon_sym_DASH_EQ); + END_STATE(); + case 56: + ACCEPT_TOKEN(anon_sym_STAR_EQ); + END_STATE(); + case 57: + ACCEPT_TOKEN(anon_sym_SLASH_EQ); + END_STATE(); + case 58: + ACCEPT_TOKEN(anon_sym_PERCENT_EQ); + END_STATE(); + case 59: + ACCEPT_TOKEN(anon_sym_BSLASH_EQ); + END_STATE(); + case 60: + ACCEPT_TOKEN(anon_sym_CARET_EQ); + END_STATE(); + case 61: + ACCEPT_TOKEN(anon_sym_DOT_DOT_EQ); + END_STATE(); + case 62: + ACCEPT_TOKEN(anon_sym_AMP_EQ); + END_STATE(); + case 63: + ACCEPT_TOKEN(anon_sym_PIPE_EQ); + END_STATE(); + case 64: + ACCEPT_TOKEN(anon_sym_CARET_CARET_EQ); + END_STATE(); + case 65: + ACCEPT_TOKEN(anon_sym_LT_LT_EQ); + END_STATE(); + case 66: + ACCEPT_TOKEN(anon_sym_GT_GT_EQ); + END_STATE(); + case 67: + ACCEPT_TOKEN(anon_sym_GT_GT_GT_EQ); + END_STATE(); + case 68: + ACCEPT_TOKEN(anon_sym_LT_LT_GT_EQ); + END_STATE(); + case 69: + ACCEPT_TOKEN(anon_sym_GT_GT_LT_EQ); + END_STATE(); + case 70: + ACCEPT_TOKEN(anon_sym_COLON_COLON); + END_STATE(); + case 71: + ACCEPT_TOKEN(anon_sym_LPAREN); + END_STATE(); + case 72: + ACCEPT_TOKEN(anon_sym_RPAREN); + END_STATE(); + case 73: + ACCEPT_TOKEN(anon_sym_DOT); + if (lookahead == '.') ADVANCE(150); + END_STATE(); + case 74: + ACCEPT_TOKEN(anon_sym_DOT); + if (lookahead == '.') ADVANCE(150); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(92); + END_STATE(); + case 75: + ACCEPT_TOKEN(anon_sym_DOT); + if (lookahead == '.') ADVANCE(149); + END_STATE(); + case 76: + ACCEPT_TOKEN(anon_sym_DOT); + if (lookahead == '.') ADVANCE(20); + END_STATE(); + case 77: + ACCEPT_TOKEN(anon_sym_COLON); + END_STATE(); + case 78: + ACCEPT_TOKEN(anon_sym_COLON); + if (lookahead == ':') ADVANCE(70); + END_STATE(); + case 79: + ACCEPT_TOKEN(anon_sym_LT); + if (lookahead == '<') ADVANCE(126); + if (lookahead == '=') ADVANCE(113); + END_STATE(); + case 80: + ACCEPT_TOKEN(anon_sym_LT); + if (lookahead == '<') ADVANCE(127); + if (lookahead == '=') ADVANCE(113); + END_STATE(); + case 81: + ACCEPT_TOKEN(anon_sym_GT); + END_STATE(); + case 82: + ACCEPT_TOKEN(anon_sym_GT); + if (lookahead == '=') ADVANCE(117); + if (lookahead == '>') ADVANCE(128); + END_STATE(); + case 83: + ACCEPT_TOKEN(anon_sym_GT); + if (lookahead == '=') ADVANCE(117); + if (lookahead == '>') ADVANCE(129); + END_STATE(); + case 84: + ACCEPT_TOKEN(anon_sym_QMARK); + END_STATE(); + case 85: + ACCEPT_TOKEN(aux_sym_include_statement_token1); + if (lookahead == '\t' || + lookahead == ' ') ADVANCE(85); + END_STATE(); + case 86: + ACCEPT_TOKEN(aux_sym_include_statement_token2); + if (lookahead == '-') ADVANCE(87); + if (lookahead == '\t' || + lookahead == 0x0b || + lookahead == '\f' || + lookahead == ' ') ADVANCE(86); + if (lookahead != 0 && + (lookahead < '\t' || '\r' < lookahead)) ADVANCE(88); + END_STATE(); + case 87: + ACCEPT_TOKEN(aux_sym_include_statement_token2); + if (lookahead == '-') ADVANCE(159); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '\r') ADVANCE(88); + END_STATE(); + case 88: + ACCEPT_TOKEN(aux_sym_include_statement_token2); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '\r') ADVANCE(88); + END_STATE(); + case 89: + ACCEPT_TOKEN(sym_number); + if (lookahead == '.') ADVANCE(92); + if (lookahead == 'B' || + lookahead == 'b') ADVANCE(39); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(38); + if (lookahead == 'X' || + lookahead == 'x') ADVANCE(6); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(90); + END_STATE(); + case 90: + ACCEPT_TOKEN(sym_number); + if (lookahead == '.') ADVANCE(92); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(38); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(90); + END_STATE(); + case 91: + ACCEPT_TOKEN(sym_number); + if (lookahead == '.') ADVANCE(93); + if (lookahead == 'P' || + lookahead == 'p') ADVANCE(38); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(91); + END_STATE(); + case 92: + ACCEPT_TOKEN(sym_number); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(38); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(92); + END_STATE(); + case 93: + ACCEPT_TOKEN(sym_number); + if (lookahead == 'P' || + lookahead == 'p') ADVANCE(38); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(93); + END_STATE(); + case 94: + ACCEPT_TOKEN(sym_number); + if (lookahead == '0' || + lookahead == '1') ADVANCE(94); + END_STATE(); + case 95: + ACCEPT_TOKEN(sym_number); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(95); + END_STATE(); + case 96: + ACCEPT_TOKEN(anon_sym_DQUOTE); + END_STATE(); + case 97: + ACCEPT_TOKEN(anon_sym_SQUOTE); + END_STATE(); + case 98: + ACCEPT_TOKEN(aux_sym__doublequote_string_content_token1); + if (lookahead == '-') ADVANCE(99); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(98); + if (lookahead != 0 && + lookahead != '"' && + lookahead != '\\') ADVANCE(100); + END_STATE(); + case 99: + ACCEPT_TOKEN(aux_sym__doublequote_string_content_token1); + if (lookahead == '-') ADVANCE(100); + if (lookahead != 0 && + lookahead != '"' && + lookahead != '\\') ADVANCE(100); + END_STATE(); + case 100: + ACCEPT_TOKEN(aux_sym__doublequote_string_content_token1); + if (lookahead != 0 && + lookahead != '"' && + lookahead != '\\') ADVANCE(100); + END_STATE(); + case 101: + ACCEPT_TOKEN(aux_sym__singlequote_string_content_token1); + if (lookahead == '-') ADVANCE(102); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(101); + if (lookahead != 0 && + lookahead != '\'' && + lookahead != '\\') ADVANCE(103); + END_STATE(); + case 102: + ACCEPT_TOKEN(aux_sym__singlequote_string_content_token1); + if (lookahead == '-') ADVANCE(103); + if (lookahead != 0 && + lookahead != '\'' && + lookahead != '\\') ADVANCE(103); + END_STATE(); + case 103: + ACCEPT_TOKEN(aux_sym__singlequote_string_content_token1); + if (lookahead != 0 && + lookahead != '\'' && + lookahead != '\\') ADVANCE(103); + END_STATE(); + case 104: + ACCEPT_TOKEN(sym_escape_sequence); + END_STATE(); + case 105: + ACCEPT_TOKEN(sym_escape_sequence); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(105); + END_STATE(); + case 106: + ACCEPT_TOKEN(sym_escape_sequence); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(104); + END_STATE(); + case 107: + ACCEPT_TOKEN(sym_escape_sequence); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(106); + END_STATE(); + case 108: + ACCEPT_TOKEN(sym_vararg_expression); + END_STATE(); + case 109: + ACCEPT_TOKEN(anon_sym_LBRACK); + END_STATE(); + case 110: + ACCEPT_TOKEN(anon_sym_RBRACK); + END_STATE(); + case 111: + ACCEPT_TOKEN(anon_sym_LBRACE); + END_STATE(); + case 112: + ACCEPT_TOKEN(anon_sym_RBRACE); + END_STATE(); + case 113: + ACCEPT_TOKEN(anon_sym_LT_EQ); + END_STATE(); + case 114: + ACCEPT_TOKEN(anon_sym_EQ_EQ); + END_STATE(); + case 115: + ACCEPT_TOKEN(anon_sym_TILDE_EQ); + END_STATE(); + case 116: + ACCEPT_TOKEN(anon_sym_BANG_EQ); + END_STATE(); + case 117: + ACCEPT_TOKEN(anon_sym_GT_EQ); + END_STATE(); + case 118: + ACCEPT_TOKEN(anon_sym_PIPE); + END_STATE(); + case 119: + ACCEPT_TOKEN(anon_sym_PIPE); + if (lookahead == '=') ADVANCE(63); + END_STATE(); + case 120: + ACCEPT_TOKEN(anon_sym_TILDE); + END_STATE(); + case 121: + ACCEPT_TOKEN(anon_sym_TILDE); + if (lookahead == '=') ADVANCE(115); + END_STATE(); + case 122: + ACCEPT_TOKEN(anon_sym_CARET_CARET); + END_STATE(); + case 123: + ACCEPT_TOKEN(anon_sym_CARET_CARET); + if (lookahead == '=') ADVANCE(64); + END_STATE(); + case 124: + ACCEPT_TOKEN(anon_sym_AMP); + END_STATE(); + case 125: + ACCEPT_TOKEN(anon_sym_AMP); + if (lookahead == '=') ADVANCE(62); + END_STATE(); + case 126: + ACCEPT_TOKEN(anon_sym_LT_LT); + if (lookahead == '=') ADVANCE(65); + if (lookahead == '>') ADVANCE(133); + END_STATE(); + case 127: + ACCEPT_TOKEN(anon_sym_LT_LT); + if (lookahead == '>') ADVANCE(132); + END_STATE(); + case 128: + ACCEPT_TOKEN(anon_sym_GT_GT); + if (lookahead == '<') ADVANCE(135); + if (lookahead == '=') ADVANCE(66); + if (lookahead == '>') ADVANCE(131); + END_STATE(); + case 129: + ACCEPT_TOKEN(anon_sym_GT_GT); + if (lookahead == '<') ADVANCE(134); + if (lookahead == '>') ADVANCE(130); + END_STATE(); + case 130: + ACCEPT_TOKEN(anon_sym_GT_GT_GT); + END_STATE(); + case 131: + ACCEPT_TOKEN(anon_sym_GT_GT_GT); + if (lookahead == '=') ADVANCE(67); + END_STATE(); + case 132: + ACCEPT_TOKEN(anon_sym_LT_LT_GT); + END_STATE(); + case 133: + ACCEPT_TOKEN(anon_sym_LT_LT_GT); + if (lookahead == '=') ADVANCE(68); + END_STATE(); + case 134: + ACCEPT_TOKEN(anon_sym_GT_GT_LT); + END_STATE(); + case 135: + ACCEPT_TOKEN(anon_sym_GT_GT_LT); + if (lookahead == '=') ADVANCE(69); + END_STATE(); + case 136: + ACCEPT_TOKEN(anon_sym_PLUS); + END_STATE(); + case 137: + ACCEPT_TOKEN(anon_sym_PLUS); + if (lookahead == '=') ADVANCE(54); + END_STATE(); + case 138: + ACCEPT_TOKEN(anon_sym_DASH); + if (lookahead == '-') ADVANCE(158); + END_STATE(); + case 139: + ACCEPT_TOKEN(anon_sym_DASH); + if (lookahead == '-') ADVANCE(158); + if (lookahead == '=') ADVANCE(55); + END_STATE(); + case 140: + ACCEPT_TOKEN(anon_sym_STAR); + END_STATE(); + case 141: + ACCEPT_TOKEN(anon_sym_STAR); + if (lookahead == '=') ADVANCE(56); + END_STATE(); + case 142: + ACCEPT_TOKEN(anon_sym_SLASH); + if (lookahead == '/') ADVANCE(144); + END_STATE(); + case 143: + ACCEPT_TOKEN(anon_sym_SLASH); + if (lookahead == '/') ADVANCE(144); + if (lookahead == '=') ADVANCE(57); + END_STATE(); + case 144: + ACCEPT_TOKEN(anon_sym_SLASH_SLASH); + END_STATE(); + case 145: + ACCEPT_TOKEN(anon_sym_PERCENT); + END_STATE(); + case 146: + ACCEPT_TOKEN(anon_sym_PERCENT); + if (lookahead == '=') ADVANCE(58); + END_STATE(); + case 147: + ACCEPT_TOKEN(anon_sym_BSLASH); + END_STATE(); + case 148: + ACCEPT_TOKEN(anon_sym_BSLASH); + if (lookahead == '=') ADVANCE(59); + END_STATE(); + case 149: + ACCEPT_TOKEN(anon_sym_DOT_DOT); + END_STATE(); + case 150: + ACCEPT_TOKEN(anon_sym_DOT_DOT); + if (lookahead == '=') ADVANCE(61); + END_STATE(); + case 151: + ACCEPT_TOKEN(anon_sym_CARET); + if (lookahead == '=') ADVANCE(60); + if (lookahead == '^') ADVANCE(123); + END_STATE(); + case 152: + ACCEPT_TOKEN(anon_sym_CARET); + if (lookahead == '^') ADVANCE(122); + END_STATE(); + case 153: + ACCEPT_TOKEN(anon_sym_POUND); + END_STATE(); + case 154: + ACCEPT_TOKEN(anon_sym_POUND); + if (lookahead == '!') ADVANCE(49); + END_STATE(); + case 155: + ACCEPT_TOKEN(anon_sym_AT); + END_STATE(); + case 156: + ACCEPT_TOKEN(anon_sym_DOLLAR); + END_STATE(); + case 157: + ACCEPT_TOKEN(sym_identifier); + if (lookahead > '/' && + (lookahead < ':' || '@' < lookahead) && + (lookahead < '[' || '^' < lookahead) && + (lookahead < '{' || 0x9f < lookahead)) ADVANCE(157); + END_STATE(); + case 158: + ACCEPT_TOKEN(anon_sym_DASH_DASH); + END_STATE(); + case 159: + ACCEPT_TOKEN(anon_sym_DASH_DASH); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '\r') ADVANCE(88); + END_STATE(); + case 160: + ACCEPT_TOKEN(anon_sym_DASH_DASH); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '\r') ADVANCE(163); + END_STATE(); + case 161: + ACCEPT_TOKEN(aux_sym_comment_token1); + if (lookahead == '-') ADVANCE(162); + if (lookahead == '\t' || + lookahead == 0x0b || + lookahead == '\f' || + lookahead == ' ') ADVANCE(161); + if (lookahead != 0 && + (lookahead < '\t' || '\r' < lookahead)) ADVANCE(163); + END_STATE(); + case 162: + ACCEPT_TOKEN(aux_sym_comment_token1); + if (lookahead == '-') ADVANCE(160); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '\r') ADVANCE(163); + END_STATE(); + case 163: + ACCEPT_TOKEN(aux_sym_comment_token1); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '\r') ADVANCE(163); + END_STATE(); + default: + return false; + } +} + +static bool ts_lex_keywords(TSLexer *lexer, TSStateId state) { + START_LEXER(); + eof = lexer->eof(lexer); + switch (state) { + case 0: + ADVANCE_MAP( + 'a', 1, + 'b', 2, + 'd', 3, + 'e', 4, + 'f', 5, + 'g', 6, + 'i', 7, + 'l', 8, + 'n', 9, + 'o', 10, + 'r', 11, + 't', 12, + 'u', 13, + 'w', 14, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(0); + END_STATE(); + case 1: + if (lookahead == 'n') ADVANCE(15); + END_STATE(); + case 2: + if (lookahead == 'r') ADVANCE(16); + END_STATE(); + case 3: + if (lookahead == 'o') ADVANCE(17); + END_STATE(); + case 4: + if (lookahead == 'l') ADVANCE(18); + if (lookahead == 'n') ADVANCE(19); + END_STATE(); + case 5: + if (lookahead == 'a') ADVANCE(20); + if (lookahead == 'o') ADVANCE(21); + if (lookahead == 'u') ADVANCE(22); + END_STATE(); + case 6: + if (lookahead == 'o') ADVANCE(23); + END_STATE(); + case 7: + if (lookahead == 'f') ADVANCE(24); + if (lookahead == 'n') ADVANCE(25); + END_STATE(); + case 8: + if (lookahead == 'o') ADVANCE(26); + END_STATE(); + case 9: + if (lookahead == 'i') ADVANCE(27); + if (lookahead == 'o') ADVANCE(28); + END_STATE(); + case 10: + if (lookahead == 'r') ADVANCE(29); + END_STATE(); + case 11: + if (lookahead == 'e') ADVANCE(30); + END_STATE(); + case 12: + if (lookahead == 'h') ADVANCE(31); + if (lookahead == 'r') ADVANCE(32); + END_STATE(); + case 13: + if (lookahead == 'n') ADVANCE(33); + END_STATE(); + case 14: + if (lookahead == 'h') ADVANCE(34); + END_STATE(); + case 15: + if (lookahead == 'd') ADVANCE(35); + END_STATE(); + case 16: + if (lookahead == 'e') ADVANCE(36); + END_STATE(); + case 17: + ACCEPT_TOKEN(anon_sym_do); + END_STATE(); + case 18: + if (lookahead == 's') ADVANCE(37); + END_STATE(); + case 19: + if (lookahead == 'd') ADVANCE(38); + END_STATE(); + case 20: + if (lookahead == 'l') ADVANCE(39); + END_STATE(); + case 21: + if (lookahead == 'r') ADVANCE(40); + END_STATE(); + case 22: + if (lookahead == 'n') ADVANCE(41); + END_STATE(); + case 23: + if (lookahead == 't') ADVANCE(42); + END_STATE(); + case 24: + ACCEPT_TOKEN(anon_sym_if); + END_STATE(); + case 25: + ACCEPT_TOKEN(anon_sym_in); + END_STATE(); + case 26: + if (lookahead == 'c') ADVANCE(43); + END_STATE(); + case 27: + if (lookahead == 'l') ADVANCE(44); + END_STATE(); + case 28: + if (lookahead == 't') ADVANCE(45); + END_STATE(); + case 29: + ACCEPT_TOKEN(anon_sym_or); + END_STATE(); + case 30: + if (lookahead == 'p') ADVANCE(46); + if (lookahead == 't') ADVANCE(47); + END_STATE(); + case 31: + if (lookahead == 'e') ADVANCE(48); + END_STATE(); + case 32: + if (lookahead == 'u') ADVANCE(49); + END_STATE(); + case 33: + if (lookahead == 't') ADVANCE(50); + END_STATE(); + case 34: + if (lookahead == 'i') ADVANCE(51); + END_STATE(); + case 35: + ACCEPT_TOKEN(anon_sym_and); + END_STATE(); + case 36: + if (lookahead == 'a') ADVANCE(52); + END_STATE(); + case 37: + if (lookahead == 'e') ADVANCE(53); + END_STATE(); + case 38: + ACCEPT_TOKEN(anon_sym_end); + END_STATE(); + case 39: + if (lookahead == 's') ADVANCE(54); + END_STATE(); + case 40: + ACCEPT_TOKEN(anon_sym_for); + END_STATE(); + case 41: + if (lookahead == 'c') ADVANCE(55); + END_STATE(); + case 42: + if (lookahead == 'o') ADVANCE(56); + END_STATE(); + case 43: + if (lookahead == 'a') ADVANCE(57); + END_STATE(); + case 44: + ACCEPT_TOKEN(sym_nil); + END_STATE(); + case 45: + ACCEPT_TOKEN(anon_sym_not); + END_STATE(); + case 46: + if (lookahead == 'e') ADVANCE(58); + END_STATE(); + case 47: + if (lookahead == 'u') ADVANCE(59); + END_STATE(); + case 48: + if (lookahead == 'n') ADVANCE(60); + END_STATE(); + case 49: + if (lookahead == 'e') ADVANCE(61); + END_STATE(); + case 50: + if (lookahead == 'i') ADVANCE(62); + END_STATE(); + case 51: + if (lookahead == 'l') ADVANCE(63); + END_STATE(); + case 52: + if (lookahead == 'k') ADVANCE(64); + END_STATE(); + case 53: + ACCEPT_TOKEN(anon_sym_else); + if (lookahead == 'i') ADVANCE(65); + END_STATE(); + case 54: + if (lookahead == 'e') ADVANCE(66); + END_STATE(); + case 55: + if (lookahead == 't') ADVANCE(67); + END_STATE(); + case 56: + ACCEPT_TOKEN(anon_sym_goto); + END_STATE(); + case 57: + if (lookahead == 'l') ADVANCE(68); + END_STATE(); + case 58: + if (lookahead == 'a') ADVANCE(69); + END_STATE(); + case 59: + if (lookahead == 'r') ADVANCE(70); + END_STATE(); + case 60: + ACCEPT_TOKEN(anon_sym_then); + END_STATE(); + case 61: + ACCEPT_TOKEN(sym_true); + END_STATE(); + case 62: + if (lookahead == 'l') ADVANCE(71); + END_STATE(); + case 63: + if (lookahead == 'e') ADVANCE(72); + END_STATE(); + case 64: + ACCEPT_TOKEN(sym_break_statement); + END_STATE(); + case 65: + if (lookahead == 'f') ADVANCE(73); + END_STATE(); + case 66: + ACCEPT_TOKEN(sym_false); + END_STATE(); + case 67: + if (lookahead == 'i') ADVANCE(74); + END_STATE(); + case 68: + ACCEPT_TOKEN(anon_sym_local); + END_STATE(); + case 69: + if (lookahead == 't') ADVANCE(75); + END_STATE(); + case 70: + if (lookahead == 'n') ADVANCE(76); + END_STATE(); + case 71: + ACCEPT_TOKEN(anon_sym_until); + END_STATE(); + case 72: + ACCEPT_TOKEN(anon_sym_while); + END_STATE(); + case 73: + ACCEPT_TOKEN(anon_sym_elseif); + END_STATE(); + case 74: + if (lookahead == 'o') ADVANCE(77); + END_STATE(); + case 75: + ACCEPT_TOKEN(anon_sym_repeat); + END_STATE(); + case 76: + ACCEPT_TOKEN(anon_sym_return); + END_STATE(); + case 77: + if (lookahead == 'n') ADVANCE(78); + END_STATE(); + case 78: + ACCEPT_TOKEN(anon_sym_function); + END_STATE(); + default: + return false; + } +} + +static const TSLexMode ts_lex_modes[STATE_COUNT] = { + [0] = {.lex_state = 0, .external_lex_state = 1}, + [1] = {.lex_state = 45, .external_lex_state = 2}, + [2] = {.lex_state = 45, .external_lex_state = 3}, + [3] = {.lex_state = 45, .external_lex_state = 3}, + [4] = {.lex_state = 46, .external_lex_state = 3}, + [5] = {.lex_state = 45, .external_lex_state = 3}, + [6] = {.lex_state = 46, .external_lex_state = 3}, + [7] = {.lex_state = 46, .external_lex_state = 3}, + [8] = {.lex_state = 46, .external_lex_state = 3}, + [9] = {.lex_state = 46, .external_lex_state = 3}, + [10] = {.lex_state = 46, .external_lex_state = 3}, + [11] = {.lex_state = 46, .external_lex_state = 3}, + [12] = {.lex_state = 46, .external_lex_state = 3}, + [13] = {.lex_state = 46, .external_lex_state = 3}, + [14] = {.lex_state = 46, .external_lex_state = 3}, + [15] = {.lex_state = 46, .external_lex_state = 3}, + [16] = {.lex_state = 46, .external_lex_state = 3}, + [17] = {.lex_state = 46, .external_lex_state = 3}, + [18] = {.lex_state = 46, .external_lex_state = 3}, + [19] = {.lex_state = 46, .external_lex_state = 3}, + [20] = {.lex_state = 46, .external_lex_state = 3}, + [21] = {.lex_state = 46, .external_lex_state = 3}, + [22] = {.lex_state = 46, .external_lex_state = 3}, + [23] = {.lex_state = 46, .external_lex_state = 3}, + [24] = {.lex_state = 46, .external_lex_state = 3}, + [25] = {.lex_state = 46, .external_lex_state = 3}, + [26] = {.lex_state = 46, .external_lex_state = 3}, + [27] = {.lex_state = 46, .external_lex_state = 3}, + [28] = {.lex_state = 46, .external_lex_state = 3}, + [29] = {.lex_state = 46, .external_lex_state = 3}, + [30] = {.lex_state = 46, .external_lex_state = 3}, + [31] = {.lex_state = 46, .external_lex_state = 3}, + [32] = {.lex_state = 46, .external_lex_state = 3}, + [33] = {.lex_state = 46, .external_lex_state = 3}, + [34] = {.lex_state = 46, .external_lex_state = 3}, + [35] = {.lex_state = 46, .external_lex_state = 3}, + [36] = {.lex_state = 46, .external_lex_state = 3}, + [37] = {.lex_state = 46, .external_lex_state = 3}, + [38] = {.lex_state = 46, .external_lex_state = 3}, + [39] = {.lex_state = 46, .external_lex_state = 3}, + [40] = {.lex_state = 46, .external_lex_state = 3}, + [41] = {.lex_state = 46, .external_lex_state = 3}, + [42] = {.lex_state = 46, .external_lex_state = 2}, + [43] = {.lex_state = 46, .external_lex_state = 2}, + [44] = {.lex_state = 46, .external_lex_state = 2}, + [45] = {.lex_state = 46, .external_lex_state = 2}, + [46] = {.lex_state = 46, .external_lex_state = 2}, + [47] = {.lex_state = 46, .external_lex_state = 2}, + [48] = {.lex_state = 46, .external_lex_state = 2}, + [49] = {.lex_state = 46, .external_lex_state = 2}, + [50] = {.lex_state = 46, .external_lex_state = 2}, + [51] = {.lex_state = 46, .external_lex_state = 2}, + [52] = {.lex_state = 46, .external_lex_state = 2}, + [53] = {.lex_state = 46, .external_lex_state = 2}, + [54] = {.lex_state = 46, .external_lex_state = 2}, + [55] = {.lex_state = 46, .external_lex_state = 2}, + [56] = {.lex_state = 46, .external_lex_state = 2}, + [57] = {.lex_state = 46, .external_lex_state = 2}, + [58] = {.lex_state = 46, .external_lex_state = 2}, + [59] = {.lex_state = 46, .external_lex_state = 2}, + [60] = {.lex_state = 46, .external_lex_state = 2}, + [61] = {.lex_state = 46, .external_lex_state = 2}, + [62] = {.lex_state = 46, .external_lex_state = 2}, + [63] = {.lex_state = 46, .external_lex_state = 2}, + [64] = {.lex_state = 46, .external_lex_state = 2}, + [65] = {.lex_state = 45, .external_lex_state = 2}, + [66] = {.lex_state = 45, .external_lex_state = 2}, + [67] = {.lex_state = 46, .external_lex_state = 2}, + [68] = {.lex_state = 46, .external_lex_state = 2}, + [69] = {.lex_state = 46, .external_lex_state = 2}, + [70] = {.lex_state = 46, .external_lex_state = 2}, + [71] = {.lex_state = 46, .external_lex_state = 2}, + [72] = {.lex_state = 46, .external_lex_state = 2}, + [73] = {.lex_state = 45, .external_lex_state = 2}, + [74] = {.lex_state = 45, .external_lex_state = 2}, + [75] = {.lex_state = 46, .external_lex_state = 2}, + [76] = {.lex_state = 46, .external_lex_state = 2}, + [77] = {.lex_state = 46, .external_lex_state = 2}, + [78] = {.lex_state = 46, .external_lex_state = 2}, + [79] = {.lex_state = 46, .external_lex_state = 2}, + [80] = {.lex_state = 46, .external_lex_state = 2}, + [81] = {.lex_state = 46, .external_lex_state = 2}, + [82] = {.lex_state = 46, .external_lex_state = 2}, + [83] = {.lex_state = 46, .external_lex_state = 2}, + [84] = {.lex_state = 46, .external_lex_state = 2}, + [85] = {.lex_state = 46, .external_lex_state = 2}, + [86] = {.lex_state = 46, .external_lex_state = 2}, + [87] = {.lex_state = 46, .external_lex_state = 2}, + [88] = {.lex_state = 46, .external_lex_state = 2}, + [89] = {.lex_state = 46, .external_lex_state = 2}, + [90] = {.lex_state = 46, .external_lex_state = 2}, + [91] = {.lex_state = 46, .external_lex_state = 2}, + [92] = {.lex_state = 46, .external_lex_state = 2}, + [93] = {.lex_state = 46, .external_lex_state = 2}, + [94] = {.lex_state = 46, .external_lex_state = 2}, + [95] = {.lex_state = 46, .external_lex_state = 2}, + [96] = {.lex_state = 46, .external_lex_state = 2}, + [97] = {.lex_state = 46, .external_lex_state = 2}, + [98] = {.lex_state = 46, .external_lex_state = 2}, + [99] = {.lex_state = 46, .external_lex_state = 2}, + [100] = {.lex_state = 46, .external_lex_state = 2}, + [101] = {.lex_state = 46, .external_lex_state = 2}, + [102] = {.lex_state = 46, .external_lex_state = 2}, + [103] = {.lex_state = 46, .external_lex_state = 2}, + [104] = {.lex_state = 45, .external_lex_state = 2}, + [105] = {.lex_state = 45, .external_lex_state = 2}, + [106] = {.lex_state = 46, .external_lex_state = 2}, + [107] = {.lex_state = 45, .external_lex_state = 2}, + [108] = {.lex_state = 46, .external_lex_state = 2}, + [109] = {.lex_state = 45, .external_lex_state = 2}, + [110] = {.lex_state = 45, .external_lex_state = 2}, + [111] = {.lex_state = 45, .external_lex_state = 2}, + [112] = {.lex_state = 45, .external_lex_state = 2}, + [113] = {.lex_state = 45, .external_lex_state = 2}, + [114] = {.lex_state = 45, .external_lex_state = 2}, + [115] = {.lex_state = 45, .external_lex_state = 2}, + [116] = {.lex_state = 45, .external_lex_state = 2}, + [117] = {.lex_state = 45, .external_lex_state = 2}, + [118] = {.lex_state = 45, .external_lex_state = 2}, + [119] = {.lex_state = 45, .external_lex_state = 2}, + [120] = {.lex_state = 45, .external_lex_state = 2}, + [121] = {.lex_state = 45, .external_lex_state = 2}, + [122] = {.lex_state = 45, .external_lex_state = 2}, + [123] = {.lex_state = 45, .external_lex_state = 2}, + [124] = {.lex_state = 45, .external_lex_state = 2}, + [125] = {.lex_state = 45, .external_lex_state = 2}, + [126] = {.lex_state = 47, .external_lex_state = 3}, + [127] = {.lex_state = 46, .external_lex_state = 3}, + [128] = {.lex_state = 47, .external_lex_state = 3}, + [129] = {.lex_state = 47, .external_lex_state = 3}, + [130] = {.lex_state = 47, .external_lex_state = 3}, + [131] = {.lex_state = 47, .external_lex_state = 3}, + [132] = {.lex_state = 47, .external_lex_state = 3}, + [133] = {.lex_state = 47, .external_lex_state = 3}, + [134] = {.lex_state = 46, .external_lex_state = 2}, + [135] = {.lex_state = 47, .external_lex_state = 3}, + [136] = {.lex_state = 46, .external_lex_state = 2}, + [137] = {.lex_state = 47, .external_lex_state = 3}, + [138] = {.lex_state = 47, .external_lex_state = 3}, + [139] = {.lex_state = 47, .external_lex_state = 3}, + [140] = {.lex_state = 47, .external_lex_state = 3}, + [141] = {.lex_state = 47, .external_lex_state = 3}, + [142] = {.lex_state = 47, .external_lex_state = 3}, + [143] = {.lex_state = 47, .external_lex_state = 3}, + [144] = {.lex_state = 47, .external_lex_state = 3}, + [145] = {.lex_state = 47, .external_lex_state = 3}, + [146] = {.lex_state = 47, .external_lex_state = 3}, + [147] = {.lex_state = 47, .external_lex_state = 3}, + [148] = {.lex_state = 47, .external_lex_state = 3}, + [149] = {.lex_state = 47, .external_lex_state = 3}, + [150] = {.lex_state = 47, .external_lex_state = 3}, + [151] = {.lex_state = 47, .external_lex_state = 3}, + [152] = {.lex_state = 47, .external_lex_state = 3}, + [153] = {.lex_state = 47, .external_lex_state = 3}, + [154] = {.lex_state = 47, .external_lex_state = 3}, + [155] = {.lex_state = 47, .external_lex_state = 3}, + [156] = {.lex_state = 47, .external_lex_state = 3}, + [157] = {.lex_state = 47, .external_lex_state = 3}, + [158] = {.lex_state = 47, .external_lex_state = 3}, + [159] = {.lex_state = 47, .external_lex_state = 3}, + [160] = {.lex_state = 47, .external_lex_state = 3}, + [161] = {.lex_state = 47, .external_lex_state = 3}, + [162] = {.lex_state = 47, .external_lex_state = 3}, + [163] = {.lex_state = 47, .external_lex_state = 3}, + [164] = {.lex_state = 47, .external_lex_state = 3}, + [165] = {.lex_state = 47, .external_lex_state = 3}, + [166] = {.lex_state = 47, .external_lex_state = 3}, + [167] = {.lex_state = 47, .external_lex_state = 3}, + [168] = {.lex_state = 47, .external_lex_state = 3}, + [169] = {.lex_state = 47, .external_lex_state = 3}, + [170] = {.lex_state = 47, .external_lex_state = 3}, + [171] = {.lex_state = 47, .external_lex_state = 3}, + [172] = {.lex_state = 47, .external_lex_state = 3}, + [173] = {.lex_state = 47, .external_lex_state = 3}, + [174] = {.lex_state = 47, .external_lex_state = 3}, + [175] = {.lex_state = 47, .external_lex_state = 3}, + [176] = {.lex_state = 47, .external_lex_state = 3}, + [177] = {.lex_state = 47, .external_lex_state = 3}, + [178] = {.lex_state = 47, .external_lex_state = 3}, + [179] = {.lex_state = 47, .external_lex_state = 3}, + [180] = {.lex_state = 47, .external_lex_state = 3}, + [181] = {.lex_state = 47, .external_lex_state = 3}, + [182] = {.lex_state = 47, .external_lex_state = 3}, + [183] = {.lex_state = 47, .external_lex_state = 3}, + [184] = {.lex_state = 47, .external_lex_state = 3}, + [185] = {.lex_state = 47, .external_lex_state = 3}, + [186] = {.lex_state = 47, .external_lex_state = 3}, + [187] = {.lex_state = 47, .external_lex_state = 3}, + [188] = {.lex_state = 47, .external_lex_state = 3}, + [189] = {.lex_state = 47, .external_lex_state = 3}, + [190] = {.lex_state = 47, .external_lex_state = 3}, + [191] = {.lex_state = 47, .external_lex_state = 3}, + [192] = {.lex_state = 47, .external_lex_state = 3}, + [193] = {.lex_state = 47, .external_lex_state = 3}, + [194] = {.lex_state = 47, .external_lex_state = 3}, + [195] = {.lex_state = 47, .external_lex_state = 3}, + [196] = {.lex_state = 47, .external_lex_state = 3}, + [197] = {.lex_state = 47, .external_lex_state = 3}, + [198] = {.lex_state = 47, .external_lex_state = 3}, + [199] = {.lex_state = 47, .external_lex_state = 3}, + [200] = {.lex_state = 47, .external_lex_state = 3}, + [201] = {.lex_state = 47, .external_lex_state = 3}, + [202] = {.lex_state = 47, .external_lex_state = 3}, + [203] = {.lex_state = 47, .external_lex_state = 3}, + [204] = {.lex_state = 46, .external_lex_state = 2}, + [205] = {.lex_state = 46, .external_lex_state = 2}, + [206] = {.lex_state = 46, .external_lex_state = 2}, + [207] = {.lex_state = 46, .external_lex_state = 2}, + [208] = {.lex_state = 46, .external_lex_state = 2}, + [209] = {.lex_state = 46, .external_lex_state = 2}, + [210] = {.lex_state = 46, .external_lex_state = 2}, + [211] = {.lex_state = 46, .external_lex_state = 2}, + [212] = {.lex_state = 46, .external_lex_state = 2}, + [213] = {.lex_state = 46, .external_lex_state = 2}, + [214] = {.lex_state = 46, .external_lex_state = 2}, + [215] = {.lex_state = 46, .external_lex_state = 2}, + [216] = {.lex_state = 46, .external_lex_state = 2}, + [217] = {.lex_state = 46, .external_lex_state = 2}, + [218] = {.lex_state = 46, .external_lex_state = 2}, + [219] = {.lex_state = 46, .external_lex_state = 2}, + [220] = {.lex_state = 46, .external_lex_state = 2}, + [221] = {.lex_state = 46, .external_lex_state = 2}, + [222] = {.lex_state = 46, .external_lex_state = 2}, + [223] = {.lex_state = 46, .external_lex_state = 2}, + [224] = {.lex_state = 46, .external_lex_state = 2}, + [225] = {.lex_state = 46, .external_lex_state = 2}, + [226] = {.lex_state = 46, .external_lex_state = 2}, + [227] = {.lex_state = 45, .external_lex_state = 3}, + [228] = {.lex_state = 46, .external_lex_state = 2}, + [229] = {.lex_state = 2, .external_lex_state = 3}, + [230] = {.lex_state = 2, .external_lex_state = 3}, + [231] = {.lex_state = 45, .external_lex_state = 3}, + [232] = {.lex_state = 46, .external_lex_state = 2}, + [233] = {.lex_state = 46, .external_lex_state = 2}, + [234] = {.lex_state = 46, .external_lex_state = 2}, + [235] = {.lex_state = 46, .external_lex_state = 2}, + [236] = {.lex_state = 46, .external_lex_state = 2}, + [237] = {.lex_state = 45, .external_lex_state = 2}, + [238] = {.lex_state = 45, .external_lex_state = 2}, + [239] = {.lex_state = 45, .external_lex_state = 2}, + [240] = {.lex_state = 46, .external_lex_state = 2}, + [241] = {.lex_state = 45, .external_lex_state = 2}, + [242] = {.lex_state = 45, .external_lex_state = 2}, + [243] = {.lex_state = 45, .external_lex_state = 2}, + [244] = {.lex_state = 45, .external_lex_state = 2}, + [245] = {.lex_state = 45, .external_lex_state = 2}, + [246] = {.lex_state = 45, .external_lex_state = 2}, + [247] = {.lex_state = 45, .external_lex_state = 2}, + [248] = {.lex_state = 45, .external_lex_state = 2}, + [249] = {.lex_state = 45, .external_lex_state = 2}, + [250] = {.lex_state = 45, .external_lex_state = 2}, + [251] = {.lex_state = 45, .external_lex_state = 2}, + [252] = {.lex_state = 45, .external_lex_state = 2}, + [253] = {.lex_state = 45, .external_lex_state = 2}, + [254] = {.lex_state = 45, .external_lex_state = 2}, + [255] = {.lex_state = 45, .external_lex_state = 2}, + [256] = {.lex_state = 45, .external_lex_state = 2}, + [257] = {.lex_state = 45, .external_lex_state = 2}, + [258] = {.lex_state = 45, .external_lex_state = 2}, + [259] = {.lex_state = 45, .external_lex_state = 2}, + [260] = {.lex_state = 45, .external_lex_state = 2}, + [261] = {.lex_state = 45, .external_lex_state = 2}, + [262] = {.lex_state = 45, .external_lex_state = 2}, + [263] = {.lex_state = 45, .external_lex_state = 2}, + [264] = {.lex_state = 45, .external_lex_state = 2}, + [265] = {.lex_state = 45, .external_lex_state = 2}, + [266] = {.lex_state = 45, .external_lex_state = 2}, + [267] = {.lex_state = 45, .external_lex_state = 2}, + [268] = {.lex_state = 45, .external_lex_state = 2}, + [269] = {.lex_state = 45, .external_lex_state = 2}, + [270] = {.lex_state = 45, .external_lex_state = 2}, + [271] = {.lex_state = 45, .external_lex_state = 2}, + [272] = {.lex_state = 45, .external_lex_state = 2}, + [273] = {.lex_state = 45, .external_lex_state = 2}, + [274] = {.lex_state = 47, .external_lex_state = 3}, + [275] = {.lex_state = 45, .external_lex_state = 2}, + [276] = {.lex_state = 45, .external_lex_state = 2}, + [277] = {.lex_state = 45, .external_lex_state = 2}, + [278] = {.lex_state = 45, .external_lex_state = 2}, + [279] = {.lex_state = 45, .external_lex_state = 2}, + [280] = {.lex_state = 45, .external_lex_state = 2}, + [281] = {.lex_state = 45, .external_lex_state = 2}, + [282] = {.lex_state = 45, .external_lex_state = 2}, + [283] = {.lex_state = 45, .external_lex_state = 2}, + [284] = {.lex_state = 45, .external_lex_state = 2}, + [285] = {.lex_state = 45, .external_lex_state = 2}, + [286] = {.lex_state = 45, .external_lex_state = 2}, + [287] = {.lex_state = 45, .external_lex_state = 2}, + [288] = {.lex_state = 45, .external_lex_state = 2}, + [289] = {.lex_state = 45, .external_lex_state = 2}, + [290] = {.lex_state = 45, .external_lex_state = 2}, + [291] = {.lex_state = 45, .external_lex_state = 2}, + [292] = {.lex_state = 45, .external_lex_state = 2}, + [293] = {.lex_state = 45, .external_lex_state = 2}, + [294] = {.lex_state = 45, .external_lex_state = 2}, + [295] = {.lex_state = 45, .external_lex_state = 2}, + [296] = {.lex_state = 45, .external_lex_state = 2}, + [297] = {.lex_state = 45, .external_lex_state = 2}, + [298] = {.lex_state = 45, .external_lex_state = 2}, + [299] = {.lex_state = 45, .external_lex_state = 2}, + [300] = {.lex_state = 45, .external_lex_state = 2}, + [301] = {.lex_state = 45, .external_lex_state = 2}, + [302] = {.lex_state = 45, .external_lex_state = 2}, + [303] = {.lex_state = 45, .external_lex_state = 2}, + [304] = {.lex_state = 45, .external_lex_state = 2}, + [305] = {.lex_state = 45, .external_lex_state = 2}, + [306] = {.lex_state = 45, .external_lex_state = 2}, + [307] = {.lex_state = 45, .external_lex_state = 2}, + [308] = {.lex_state = 45, .external_lex_state = 2}, + [309] = {.lex_state = 45, .external_lex_state = 2}, + [310] = {.lex_state = 45, .external_lex_state = 2}, + [311] = {.lex_state = 45, .external_lex_state = 2}, + [312] = {.lex_state = 45, .external_lex_state = 2}, + [313] = {.lex_state = 45, .external_lex_state = 2}, + [314] = {.lex_state = 45, .external_lex_state = 2}, + [315] = {.lex_state = 45, .external_lex_state = 2}, + [316] = {.lex_state = 45, .external_lex_state = 2}, + [317] = {.lex_state = 45, .external_lex_state = 2}, + [318] = {.lex_state = 45, .external_lex_state = 2}, + [319] = {.lex_state = 45, .external_lex_state = 2}, + [320] = {.lex_state = 45, .external_lex_state = 2}, + [321] = {.lex_state = 45, .external_lex_state = 2}, + [322] = {.lex_state = 45, .external_lex_state = 2}, + [323] = {.lex_state = 45, .external_lex_state = 2}, + [324] = {.lex_state = 45, .external_lex_state = 2}, + [325] = {.lex_state = 45, .external_lex_state = 2}, + [326] = {.lex_state = 45, .external_lex_state = 2}, + [327] = {.lex_state = 45, .external_lex_state = 2}, + [328] = {.lex_state = 45, .external_lex_state = 2}, + [329] = {.lex_state = 45, .external_lex_state = 2}, + [330] = {.lex_state = 45, .external_lex_state = 2}, + [331] = {.lex_state = 45, .external_lex_state = 2}, + [332] = {.lex_state = 45, .external_lex_state = 2}, + [333] = {.lex_state = 45, .external_lex_state = 3}, + [334] = {.lex_state = 45, .external_lex_state = 3}, + [335] = {.lex_state = 45, .external_lex_state = 3}, + [336] = {.lex_state = 0, .external_lex_state = 3}, + [337] = {.lex_state = 0, .external_lex_state = 2}, + [338] = {.lex_state = 45, .external_lex_state = 3}, + [339] = {.lex_state = 0, .external_lex_state = 3}, + [340] = {.lex_state = 0, .external_lex_state = 2}, + [341] = {.lex_state = 0, .external_lex_state = 2}, + [342] = {.lex_state = 45, .external_lex_state = 3}, + [343] = {.lex_state = 46, .external_lex_state = 2}, + [344] = {.lex_state = 0, .external_lex_state = 2}, + [345] = {.lex_state = 0, .external_lex_state = 2}, + [346] = {.lex_state = 0, .external_lex_state = 2}, + [347] = {.lex_state = 46, .external_lex_state = 2}, + [348] = {.lex_state = 0, .external_lex_state = 2}, + [349] = {.lex_state = 0, .external_lex_state = 2}, + [350] = {.lex_state = 0, .external_lex_state = 2}, + [351] = {.lex_state = 0, .external_lex_state = 2}, + [352] = {.lex_state = 0, .external_lex_state = 2}, + [353] = {.lex_state = 0, .external_lex_state = 2}, + [354] = {.lex_state = 0, .external_lex_state = 2}, + [355] = {.lex_state = 0, .external_lex_state = 3}, + [356] = {.lex_state = 0, .external_lex_state = 2}, + [357] = {.lex_state = 0, .external_lex_state = 2}, + [358] = {.lex_state = 0, .external_lex_state = 2}, + [359] = {.lex_state = 0, .external_lex_state = 2}, + [360] = {.lex_state = 0, .external_lex_state = 2}, + [361] = {.lex_state = 47, .external_lex_state = 2}, + [362] = {.lex_state = 3, .external_lex_state = 2}, + [363] = {.lex_state = 4, .external_lex_state = 2}, + [364] = {.lex_state = 0, .external_lex_state = 2}, + [365] = {.lex_state = 4, .external_lex_state = 2}, + [366] = {.lex_state = 3, .external_lex_state = 2}, + [367] = {.lex_state = 4, .external_lex_state = 2}, + [368] = {.lex_state = 0, .external_lex_state = 2}, + [369] = {.lex_state = 4, .external_lex_state = 2}, + [370] = {.lex_state = 0, .external_lex_state = 2}, + [371] = {.lex_state = 3, .external_lex_state = 2}, + [372] = {.lex_state = 4, .external_lex_state = 2}, + [373] = {.lex_state = 3, .external_lex_state = 2}, + [374] = {.lex_state = 4, .external_lex_state = 2}, + [375] = {.lex_state = 3, .external_lex_state = 2}, + [376] = {.lex_state = 4, .external_lex_state = 2}, + [377] = {.lex_state = 3, .external_lex_state = 2}, + [378] = {.lex_state = 4, .external_lex_state = 2}, + [379] = {.lex_state = 3, .external_lex_state = 2}, + [380] = {.lex_state = 4, .external_lex_state = 2}, + [381] = {.lex_state = 0, .external_lex_state = 2}, + [382] = {.lex_state = 0, .external_lex_state = 2}, + [383] = {.lex_state = 3, .external_lex_state = 2}, + [384] = {.lex_state = 0, .external_lex_state = 2}, + [385] = {.lex_state = 3, .external_lex_state = 2}, + [386] = {.lex_state = 0, .external_lex_state = 2}, + [387] = {.lex_state = 3, .external_lex_state = 2}, + [388] = {.lex_state = 0, .external_lex_state = 2}, + [389] = {.lex_state = 47, .external_lex_state = 2}, + [390] = {.lex_state = 0, .external_lex_state = 2}, + [391] = {.lex_state = 0, .external_lex_state = 2}, + [392] = {.lex_state = 0, .external_lex_state = 2}, + [393] = {.lex_state = 45, .external_lex_state = 2}, + [394] = {.lex_state = 0, .external_lex_state = 2}, + [395] = {.lex_state = 45, .external_lex_state = 2}, + [396] = {.lex_state = 0, .external_lex_state = 2}, + [397] = {.lex_state = 0, .external_lex_state = 2}, + [398] = {.lex_state = 0, .external_lex_state = 2}, + [399] = {.lex_state = 0, .external_lex_state = 2}, + [400] = {.lex_state = 0, .external_lex_state = 2}, + [401] = {.lex_state = 0, .external_lex_state = 2}, + [402] = {.lex_state = 0, .external_lex_state = 2}, + [403] = {.lex_state = 45, .external_lex_state = 2}, + [404] = {.lex_state = 0, .external_lex_state = 2}, + [405] = {.lex_state = 0, .external_lex_state = 2}, + [406] = {.lex_state = 45, .external_lex_state = 2}, + [407] = {.lex_state = 0, .external_lex_state = 2}, + [408] = {.lex_state = 4, .external_lex_state = 2}, + [409] = {.lex_state = 0, .external_lex_state = 2}, + [410] = {.lex_state = 47, .external_lex_state = 2}, + [411] = {.lex_state = 0, .external_lex_state = 2}, + [412] = {.lex_state = 0, .external_lex_state = 4}, + [413] = {.lex_state = 0, .external_lex_state = 2}, + [414] = {.lex_state = 0, .external_lex_state = 2}, + [415] = {.lex_state = 0, .external_lex_state = 2}, + [416] = {.lex_state = 0, .external_lex_state = 2}, + [417] = {.lex_state = 0, .external_lex_state = 2}, + [418] = {.lex_state = 0, .external_lex_state = 2}, + [419] = {.lex_state = 0, .external_lex_state = 5}, + [420] = {.lex_state = 0, .external_lex_state = 2}, + [421] = {.lex_state = 0, .external_lex_state = 2}, + [422] = {.lex_state = 0, .external_lex_state = 2}, + [423] = {.lex_state = 0, .external_lex_state = 2}, + [424] = {.lex_state = 0, .external_lex_state = 2}, + [425] = {.lex_state = 0, .external_lex_state = 2}, + [426] = {.lex_state = 0, .external_lex_state = 2}, + [427] = {.lex_state = 0, .external_lex_state = 2}, + [428] = {.lex_state = 0, .external_lex_state = 2}, + [429] = {.lex_state = 47, .external_lex_state = 2}, + [430] = {.lex_state = 0, .external_lex_state = 2}, + [431] = {.lex_state = 0, .external_lex_state = 2}, + [432] = {.lex_state = 0, .external_lex_state = 2}, + [433] = {.lex_state = 0, .external_lex_state = 2}, + [434] = {.lex_state = 0, .external_lex_state = 2}, + [435] = {.lex_state = 0, .external_lex_state = 2}, + [436] = {.lex_state = 0, .external_lex_state = 2}, + [437] = {.lex_state = 0, .external_lex_state = 6}, + [438] = {.lex_state = 0, .external_lex_state = 2}, + [439] = {.lex_state = 0, .external_lex_state = 2}, + [440] = {.lex_state = 86, .external_lex_state = 2}, + [441] = {.lex_state = 0, .external_lex_state = 2}, + [442] = {.lex_state = 0, .external_lex_state = 2}, + [443] = {.lex_state = 0, .external_lex_state = 2}, + [444] = {.lex_state = 0, .external_lex_state = 2}, + [445] = {.lex_state = 0, .external_lex_state = 2}, + [446] = {.lex_state = 0, .external_lex_state = 2}, + [447] = {.lex_state = 0, .external_lex_state = 2}, + [448] = {.lex_state = 0, .external_lex_state = 5}, + [449] = {.lex_state = 0, .external_lex_state = 2}, + [450] = {.lex_state = 86, .external_lex_state = 2}, + [451] = {.lex_state = 0, .external_lex_state = 2}, + [452] = {.lex_state = 0, .external_lex_state = 2}, + [453] = {.lex_state = 161, .external_lex_state = 2}, + [454] = {.lex_state = 0, .external_lex_state = 2}, + [455] = {.lex_state = 0, .external_lex_state = 5}, + [456] = {.lex_state = 0, .external_lex_state = 2}, + [457] = {.lex_state = 0, .external_lex_state = 2}, + [458] = {.lex_state = 0, .external_lex_state = 2}, + [459] = {.lex_state = 0, .external_lex_state = 2}, + [460] = {.lex_state = 0, .external_lex_state = 2}, + [461] = {.lex_state = 0, .external_lex_state = 2}, + [462] = {.lex_state = 0, .external_lex_state = 4}, + [463] = {.lex_state = 0, .external_lex_state = 2}, + [464] = {.lex_state = 0, .external_lex_state = 5}, + [465] = {.lex_state = 0, .external_lex_state = 2}, + [466] = {.lex_state = 0, .external_lex_state = 4}, + [467] = {.lex_state = 0, .external_lex_state = 2}, + [468] = {.lex_state = 0, .external_lex_state = 2}, + [469] = {.lex_state = 0, .external_lex_state = 2}, + [470] = {.lex_state = 0, .external_lex_state = 2}, + [471] = {.lex_state = 0, .external_lex_state = 2}, + [472] = {.lex_state = 0, .external_lex_state = 2}, + [473] = {.lex_state = 0, .external_lex_state = 4}, + [474] = {.lex_state = 0, .external_lex_state = 2}, + [475] = {.lex_state = 0, .external_lex_state = 2}, + [476] = {.lex_state = 0, .external_lex_state = 2}, + [477] = {.lex_state = 0, .external_lex_state = 2}, + [478] = {.lex_state = 0, .external_lex_state = 2}, + [479] = {.lex_state = 0, .external_lex_state = 2}, + [480] = {.lex_state = 0, .external_lex_state = 2}, + [481] = {.lex_state = 0, .external_lex_state = 2}, + [482] = {.lex_state = 47, .external_lex_state = 2}, + [483] = {.lex_state = 0, .external_lex_state = 2}, + [484] = {.lex_state = 0, .external_lex_state = 2}, + [485] = {.lex_state = 0, .external_lex_state = 2}, + [486] = {.lex_state = 0, .external_lex_state = 2}, + [487] = {.lex_state = 0, .external_lex_state = 7}, + [488] = {(TSStateId)(-1)}, + [489] = {(TSStateId)(-1)}, +}; + +static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { + [0] = { + [sym_comment] = STATE(0), + [ts_builtin_sym_end] = ACTIONS(1), + [sym_identifier] = ACTIONS(1), + [sym_hash_bang_line] = ACTIONS(1), + [anon_sym_return] = ACTIONS(1), + [anon_sym_SEMI] = ACTIONS(1), + [anon_sym_EQ] = ACTIONS(1), + [anon_sym_COMMA] = ACTIONS(1), + [anon_sym_PLUS_EQ] = ACTIONS(1), + [anon_sym_DASH_EQ] = ACTIONS(1), + [anon_sym_STAR_EQ] = ACTIONS(1), + [anon_sym_SLASH_EQ] = ACTIONS(1), + [anon_sym_PERCENT_EQ] = ACTIONS(1), + [anon_sym_BSLASH_EQ] = ACTIONS(1), + [anon_sym_CARET_EQ] = ACTIONS(1), + [anon_sym_DOT_DOT_EQ] = ACTIONS(1), + [anon_sym_AMP_EQ] = ACTIONS(1), + [anon_sym_PIPE_EQ] = ACTIONS(1), + [anon_sym_CARET_CARET_EQ] = ACTIONS(1), + [anon_sym_LT_LT_EQ] = ACTIONS(1), + [anon_sym_GT_GT_EQ] = ACTIONS(1), + [anon_sym_GT_GT_GT_EQ] = ACTIONS(1), + [anon_sym_LT_LT_GT_EQ] = ACTIONS(1), + [anon_sym_GT_GT_LT_EQ] = ACTIONS(1), + [anon_sym_COLON_COLON] = ACTIONS(1), + [sym_break_statement] = ACTIONS(1), + [anon_sym_goto] = ACTIONS(1), + [anon_sym_do] = ACTIONS(1), + [anon_sym_end] = ACTIONS(1), + [anon_sym_while] = ACTIONS(1), + [anon_sym_LPAREN] = ACTIONS(1), + [anon_sym_RPAREN] = ACTIONS(1), + [anon_sym_repeat] = ACTIONS(1), + [anon_sym_until] = ACTIONS(1), + [anon_sym_if] = ACTIONS(1), + [anon_sym_then] = ACTIONS(1), + [anon_sym_elseif] = ACTIONS(1), + [anon_sym_else] = ACTIONS(1), + [anon_sym_for] = ACTIONS(1), + [anon_sym_in] = ACTIONS(1), + [anon_sym_function] = ACTIONS(1), + [anon_sym_local] = ACTIONS(1), + [anon_sym_DOT] = ACTIONS(1), + [anon_sym_COLON] = ACTIONS(1), + [anon_sym_LT] = ACTIONS(1), + [anon_sym_GT] = ACTIONS(1), + [anon_sym_QMARK] = ACTIONS(1), + [sym_nil] = ACTIONS(1), + [sym_false] = ACTIONS(1), + [sym_true] = ACTIONS(1), + [sym_number] = ACTIONS(1), + [anon_sym_DQUOTE] = ACTIONS(1), + [anon_sym_SQUOTE] = ACTIONS(1), + [anon_sym_LBRACK] = ACTIONS(1), + [anon_sym_RBRACK] = ACTIONS(1), + [anon_sym_LBRACE] = ACTIONS(1), + [anon_sym_RBRACE] = ACTIONS(1), + [anon_sym_or] = ACTIONS(1), + [anon_sym_and] = ACTIONS(1), + [anon_sym_LT_EQ] = ACTIONS(1), + [anon_sym_EQ_EQ] = ACTIONS(1), + [anon_sym_TILDE_EQ] = ACTIONS(1), + [anon_sym_BANG_EQ] = ACTIONS(1), + [anon_sym_GT_EQ] = ACTIONS(1), + [anon_sym_PIPE] = ACTIONS(1), + [anon_sym_TILDE] = ACTIONS(1), + [anon_sym_CARET_CARET] = ACTIONS(1), + [anon_sym_AMP] = ACTIONS(1), + [anon_sym_LT_LT] = ACTIONS(1), + [anon_sym_GT_GT] = ACTIONS(1), + [anon_sym_GT_GT_GT] = ACTIONS(1), + [anon_sym_LT_LT_GT] = ACTIONS(1), + [anon_sym_GT_GT_LT] = ACTIONS(1), + [anon_sym_PLUS] = ACTIONS(1), + [anon_sym_DASH] = ACTIONS(1), + [anon_sym_STAR] = ACTIONS(1), + [anon_sym_SLASH] = ACTIONS(1), + [anon_sym_SLASH_SLASH] = ACTIONS(1), + [anon_sym_PERCENT] = ACTIONS(1), + [anon_sym_BSLASH] = ACTIONS(1), + [anon_sym_DOT_DOT] = ACTIONS(1), + [anon_sym_CARET] = ACTIONS(1), + [anon_sym_not] = ACTIONS(1), + [anon_sym_POUND] = ACTIONS(1), + [anon_sym_AT] = ACTIONS(1), + [anon_sym_DOLLAR] = ACTIONS(1), + [anon_sym_DASH_DASH] = ACTIONS(3), + [sym__block_comment_start] = ACTIONS(5), + [sym__block_comment_content] = ACTIONS(1), + [sym__block_comment_end] = ACTIONS(1), + [sym__block_string_start] = ACTIONS(1), + [sym__block_string_content] = ACTIONS(1), + [sym__block_string_end] = ACTIONS(1), + }, + [1] = { + [sym_chunk] = STATE(465), + [sym_statement] = STATE(286), + [sym_return_statement] = STATE(432), + [sym_empty_statement] = STATE(275), + [sym_assignment_statement] = STATE(275), + [sym__variable_assignment_varlist] = STATE(471), + [sym_compound_assignment_statement] = STATE(275), + [sym_label_statement] = STATE(275), + [sym_goto_statement] = STATE(275), + [sym_do_statement] = STATE(275), + [sym_while_statement] = STATE(275), + [sym_shorthand_while_statement] = STATE(275), + [sym_repeat_statement] = STATE(275), + [sym_if_statement] = STATE(275), + [sym_shorthand_if_statement] = STATE(275), + [sym_for_statement] = STATE(275), + [sym_declaration] = STATE(292), + [sym_function_declaration] = STATE(293), + [sym__local_function_declaration] = STATE(294), + [sym_variable_declaration] = STATE(295), + [sym_print_shorthand_statement] = STATE(275), + [sym_include_statement] = STATE(275), + [sym__prefix_expression] = STATE(335), + [sym_variable] = STATE(229), + [sym_bracket_index_expression] = STATE(2), + [sym_dot_index_expression] = STATE(2), + [sym_function_call] = STATE(227), + [sym_method_index_expression] = STATE(339), + [sym_parenthesized_expression] = STATE(342), + [sym_comment] = STATE(1), + [aux_sym_chunk_repeat1] = STATE(120), + [ts_builtin_sym_end] = ACTIONS(7), + [sym_identifier] = ACTIONS(9), + [sym_hash_bang_line] = ACTIONS(11), + [anon_sym_return] = ACTIONS(13), + [anon_sym_SEMI] = ACTIONS(15), + [anon_sym_COLON_COLON] = ACTIONS(17), + [sym_break_statement] = ACTIONS(19), + [anon_sym_goto] = ACTIONS(21), + [anon_sym_do] = ACTIONS(23), + [anon_sym_while] = ACTIONS(25), + [anon_sym_LPAREN] = ACTIONS(27), + [anon_sym_repeat] = ACTIONS(29), + [anon_sym_if] = ACTIONS(31), + [anon_sym_for] = ACTIONS(33), + [anon_sym_function] = ACTIONS(35), + [anon_sym_local] = ACTIONS(37), + [anon_sym_QMARK] = ACTIONS(39), + [aux_sym_include_statement_token1] = ACTIONS(41), + [anon_sym_DASH_DASH] = ACTIONS(3), + [sym__block_comment_start] = ACTIONS(5), + }, + [2] = { + [sym_comment] = STATE(2), + [ts_builtin_sym_end] = ACTIONS(43), + [sym_identifier] = ACTIONS(45), + [anon_sym_return] = ACTIONS(45), + [anon_sym_SEMI] = ACTIONS(43), + [anon_sym_EQ] = ACTIONS(45), + [anon_sym_COMMA] = ACTIONS(43), + [anon_sym_PLUS_EQ] = ACTIONS(43), + [anon_sym_DASH_EQ] = ACTIONS(43), + [anon_sym_STAR_EQ] = ACTIONS(43), + [anon_sym_SLASH_EQ] = ACTIONS(43), + [anon_sym_PERCENT_EQ] = ACTIONS(43), + [anon_sym_BSLASH_EQ] = ACTIONS(43), + [anon_sym_CARET_EQ] = ACTIONS(43), + [anon_sym_DOT_DOT_EQ] = ACTIONS(43), + [anon_sym_AMP_EQ] = ACTIONS(43), + [anon_sym_PIPE_EQ] = ACTIONS(43), + [anon_sym_CARET_CARET_EQ] = ACTIONS(43), + [anon_sym_LT_LT_EQ] = ACTIONS(43), + [anon_sym_GT_GT_EQ] = ACTIONS(43), + [anon_sym_GT_GT_GT_EQ] = ACTIONS(43), + [anon_sym_LT_LT_GT_EQ] = ACTIONS(43), + [anon_sym_GT_GT_LT_EQ] = ACTIONS(43), + [anon_sym_COLON_COLON] = ACTIONS(43), + [sym_break_statement] = ACTIONS(45), + [anon_sym_goto] = ACTIONS(45), + [anon_sym_do] = ACTIONS(45), + [anon_sym_end] = ACTIONS(45), + [anon_sym_while] = ACTIONS(45), + [anon_sym_LPAREN] = ACTIONS(43), + [anon_sym_RPAREN] = ACTIONS(43), + [anon_sym_repeat] = ACTIONS(45), + [anon_sym_until] = ACTIONS(45), + [anon_sym_if] = ACTIONS(45), + [anon_sym_then] = ACTIONS(45), + [anon_sym_elseif] = ACTIONS(45), + [anon_sym_else] = ACTIONS(45), + [anon_sym_for] = ACTIONS(45), + [anon_sym_function] = ACTIONS(45), + [anon_sym_local] = ACTIONS(45), + [anon_sym_DOT] = ACTIONS(45), + [anon_sym_COLON] = ACTIONS(45), + [anon_sym_LT] = ACTIONS(45), + [anon_sym_GT] = ACTIONS(45), + [anon_sym_QMARK] = ACTIONS(43), + [aux_sym_include_statement_token1] = ACTIONS(43), + [anon_sym_DQUOTE] = ACTIONS(43), + [anon_sym_SQUOTE] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(43), + [anon_sym_RBRACK] = ACTIONS(43), + [anon_sym_LBRACE] = ACTIONS(43), + [anon_sym_RBRACE] = ACTIONS(43), + [anon_sym_or] = ACTIONS(45), + [anon_sym_and] = ACTIONS(45), + [anon_sym_LT_EQ] = ACTIONS(43), + [anon_sym_EQ_EQ] = ACTIONS(43), + [anon_sym_TILDE_EQ] = ACTIONS(43), + [anon_sym_BANG_EQ] = ACTIONS(43), + [anon_sym_GT_EQ] = ACTIONS(43), + [anon_sym_PIPE] = ACTIONS(45), + [anon_sym_TILDE] = ACTIONS(45), + [anon_sym_CARET_CARET] = ACTIONS(45), + [anon_sym_AMP] = ACTIONS(45), + [anon_sym_LT_LT] = ACTIONS(45), + [anon_sym_GT_GT] = ACTIONS(45), + [anon_sym_GT_GT_GT] = ACTIONS(45), + [anon_sym_LT_LT_GT] = ACTIONS(45), + [anon_sym_GT_GT_LT] = ACTIONS(45), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(45), + [anon_sym_STAR] = ACTIONS(45), + [anon_sym_SLASH] = ACTIONS(45), + [anon_sym_SLASH_SLASH] = ACTIONS(43), + [anon_sym_PERCENT] = ACTIONS(45), + [anon_sym_BSLASH] = ACTIONS(45), + [anon_sym_DOT_DOT] = ACTIONS(45), + [anon_sym_CARET] = ACTIONS(45), + [anon_sym_DASH_DASH] = ACTIONS(3), + [sym__block_comment_start] = ACTIONS(5), + [sym__block_string_start] = ACTIONS(43), + }, + [3] = { + [sym_comment] = STATE(3), + [ts_builtin_sym_end] = ACTIONS(47), + [sym_identifier] = ACTIONS(49), + [anon_sym_return] = ACTIONS(49), + [anon_sym_SEMI] = ACTIONS(47), + [anon_sym_EQ] = ACTIONS(49), + [anon_sym_COMMA] = ACTIONS(47), + [anon_sym_PLUS_EQ] = ACTIONS(47), + [anon_sym_DASH_EQ] = ACTIONS(47), + [anon_sym_STAR_EQ] = ACTIONS(47), + [anon_sym_SLASH_EQ] = ACTIONS(47), + [anon_sym_PERCENT_EQ] = ACTIONS(47), + [anon_sym_BSLASH_EQ] = ACTIONS(47), + [anon_sym_CARET_EQ] = ACTIONS(47), + [anon_sym_DOT_DOT_EQ] = ACTIONS(47), + [anon_sym_AMP_EQ] = ACTIONS(47), + [anon_sym_PIPE_EQ] = ACTIONS(47), + [anon_sym_CARET_CARET_EQ] = ACTIONS(47), + [anon_sym_LT_LT_EQ] = ACTIONS(47), + [anon_sym_GT_GT_EQ] = ACTIONS(47), + [anon_sym_GT_GT_GT_EQ] = ACTIONS(47), + [anon_sym_LT_LT_GT_EQ] = ACTIONS(47), + [anon_sym_GT_GT_LT_EQ] = ACTIONS(47), + [anon_sym_COLON_COLON] = ACTIONS(47), + [sym_break_statement] = ACTIONS(49), + [anon_sym_goto] = ACTIONS(49), + [anon_sym_do] = ACTIONS(49), + [anon_sym_end] = ACTIONS(49), + [anon_sym_while] = ACTIONS(49), + [anon_sym_LPAREN] = ACTIONS(47), + [anon_sym_RPAREN] = ACTIONS(47), + [anon_sym_repeat] = ACTIONS(49), + [anon_sym_until] = ACTIONS(49), + [anon_sym_if] = ACTIONS(49), + [anon_sym_then] = ACTIONS(49), + [anon_sym_elseif] = ACTIONS(49), + [anon_sym_else] = ACTIONS(49), + [anon_sym_for] = ACTIONS(49), + [anon_sym_function] = ACTIONS(49), + [anon_sym_local] = ACTIONS(49), + [anon_sym_DOT] = ACTIONS(49), + [anon_sym_COLON] = ACTIONS(49), + [anon_sym_LT] = ACTIONS(49), + [anon_sym_GT] = ACTIONS(49), + [anon_sym_QMARK] = ACTIONS(47), + [aux_sym_include_statement_token1] = ACTIONS(47), + [anon_sym_DQUOTE] = ACTIONS(47), + [anon_sym_SQUOTE] = ACTIONS(47), + [anon_sym_LBRACK] = ACTIONS(47), + [anon_sym_RBRACK] = ACTIONS(47), + [anon_sym_LBRACE] = ACTIONS(47), + [anon_sym_RBRACE] = ACTIONS(47), + [anon_sym_or] = ACTIONS(49), + [anon_sym_and] = ACTIONS(49), + [anon_sym_LT_EQ] = ACTIONS(47), + [anon_sym_EQ_EQ] = ACTIONS(47), + [anon_sym_TILDE_EQ] = ACTIONS(47), + [anon_sym_BANG_EQ] = ACTIONS(47), + [anon_sym_GT_EQ] = ACTIONS(47), + [anon_sym_PIPE] = ACTIONS(49), + [anon_sym_TILDE] = ACTIONS(49), + [anon_sym_CARET_CARET] = ACTIONS(49), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_LT_LT] = ACTIONS(49), + [anon_sym_GT_GT] = ACTIONS(49), + [anon_sym_GT_GT_GT] = ACTIONS(49), + [anon_sym_LT_LT_GT] = ACTIONS(49), + [anon_sym_GT_GT_LT] = ACTIONS(49), + [anon_sym_PLUS] = ACTIONS(49), + [anon_sym_DASH] = ACTIONS(49), + [anon_sym_STAR] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(49), + [anon_sym_SLASH_SLASH] = ACTIONS(47), + [anon_sym_PERCENT] = ACTIONS(49), + [anon_sym_BSLASH] = ACTIONS(49), + [anon_sym_DOT_DOT] = ACTIONS(49), + [anon_sym_CARET] = ACTIONS(49), + [anon_sym_DASH_DASH] = ACTIONS(3), + [sym__block_comment_start] = ACTIONS(5), + [sym__block_string_start] = ACTIONS(47), + }, + [4] = { + [sym_statement] = STATE(320), + [sym_empty_statement] = STATE(304), + [sym_assignment_statement] = STATE(304), + [sym__variable_assignment_varlist] = STATE(449), + [sym_compound_assignment_statement] = STATE(304), + [sym_label_statement] = STATE(304), + [sym_goto_statement] = STATE(304), + [sym_do_statement] = STATE(304), + [sym_while_statement] = STATE(304), + [sym_shorthand_while_statement] = STATE(304), + [sym_repeat_statement] = STATE(304), + [sym_if_statement] = STATE(304), + [sym_shorthand_if_statement] = STATE(304), + [sym_for_statement] = STATE(304), + [sym_declaration] = STATE(311), + [sym_function_declaration] = STATE(317), + [sym__local_function_declaration] = STATE(318), + [sym_variable_declaration] = STATE(319), + [sym_print_shorthand_statement] = STATE(304), + [sym_include_statement] = STATE(304), + [sym__prefix_expression] = STATE(333), + [sym_variable] = STATE(230), + [sym_bracket_index_expression] = STATE(2), + [sym_dot_index_expression] = STATE(2), + [sym_function_call] = STATE(231), + [sym_method_index_expression] = STATE(336), + [sym_parenthesized_expression] = STATE(342), + [sym_comment] = STATE(4), + [sym_identifier] = ACTIONS(9), + [anon_sym_SEMI] = ACTIONS(51), + [anon_sym_COLON_COLON] = ACTIONS(53), + [sym_break_statement] = ACTIONS(55), + [anon_sym_goto] = ACTIONS(57), + [anon_sym_do] = ACTIONS(59), + [anon_sym_while] = ACTIONS(61), + [anon_sym_LPAREN] = ACTIONS(63), + [anon_sym_repeat] = ACTIONS(66), + [anon_sym_if] = ACTIONS(68), + [anon_sym_then] = ACTIONS(70), + [anon_sym_for] = ACTIONS(72), + [anon_sym_function] = ACTIONS(74), + [anon_sym_local] = ACTIONS(76), + [anon_sym_DOT] = ACTIONS(70), + [anon_sym_COLON] = ACTIONS(70), + [anon_sym_LT] = ACTIONS(70), + [anon_sym_GT] = ACTIONS(70), + [anon_sym_QMARK] = ACTIONS(78), + [aux_sym_include_statement_token1] = ACTIONS(80), + [anon_sym_DQUOTE] = ACTIONS(82), + [anon_sym_SQUOTE] = ACTIONS(82), + [anon_sym_LBRACK] = ACTIONS(82), + [anon_sym_LBRACE] = ACTIONS(82), + [anon_sym_or] = ACTIONS(70), + [anon_sym_and] = ACTIONS(70), + [anon_sym_LT_EQ] = ACTIONS(82), + [anon_sym_EQ_EQ] = ACTIONS(82), + [anon_sym_TILDE_EQ] = ACTIONS(82), + [anon_sym_BANG_EQ] = ACTIONS(82), + [anon_sym_GT_EQ] = ACTIONS(82), + [anon_sym_PIPE] = ACTIONS(82), + [anon_sym_TILDE] = ACTIONS(70), + [anon_sym_CARET_CARET] = ACTIONS(82), + [anon_sym_AMP] = ACTIONS(82), + [anon_sym_LT_LT] = ACTIONS(70), + [anon_sym_GT_GT] = ACTIONS(70), + [anon_sym_GT_GT_GT] = ACTIONS(82), + [anon_sym_LT_LT_GT] = ACTIONS(82), + [anon_sym_GT_GT_LT] = ACTIONS(82), + [anon_sym_PLUS] = ACTIONS(82), + [anon_sym_DASH] = ACTIONS(70), + [anon_sym_STAR] = ACTIONS(82), + [anon_sym_SLASH] = ACTIONS(70), + [anon_sym_SLASH_SLASH] = ACTIONS(82), + [anon_sym_PERCENT] = ACTIONS(82), + [anon_sym_BSLASH] = ACTIONS(82), + [anon_sym_DOT_DOT] = ACTIONS(82), + [anon_sym_CARET] = ACTIONS(70), + [anon_sym_DASH_DASH] = ACTIONS(3), + [sym__block_comment_start] = ACTIONS(5), + [sym__block_string_start] = ACTIONS(82), + }, + [5] = { + [sym_comment] = STATE(5), + [ts_builtin_sym_end] = ACTIONS(84), + [sym_identifier] = ACTIONS(86), + [anon_sym_return] = ACTIONS(86), + [anon_sym_SEMI] = ACTIONS(84), + [anon_sym_EQ] = ACTIONS(86), + [anon_sym_COMMA] = ACTIONS(84), + [anon_sym_PLUS_EQ] = ACTIONS(84), + [anon_sym_DASH_EQ] = ACTIONS(84), + [anon_sym_STAR_EQ] = ACTIONS(84), + [anon_sym_SLASH_EQ] = ACTIONS(84), + [anon_sym_PERCENT_EQ] = ACTIONS(84), + [anon_sym_BSLASH_EQ] = ACTIONS(84), + [anon_sym_CARET_EQ] = ACTIONS(84), + [anon_sym_DOT_DOT_EQ] = ACTIONS(84), + [anon_sym_AMP_EQ] = ACTIONS(84), + [anon_sym_PIPE_EQ] = ACTIONS(84), + [anon_sym_CARET_CARET_EQ] = ACTIONS(84), + [anon_sym_LT_LT_EQ] = ACTIONS(84), + [anon_sym_GT_GT_EQ] = ACTIONS(84), + [anon_sym_GT_GT_GT_EQ] = ACTIONS(84), + [anon_sym_LT_LT_GT_EQ] = ACTIONS(84), + [anon_sym_GT_GT_LT_EQ] = ACTIONS(84), + [anon_sym_COLON_COLON] = ACTIONS(84), + [sym_break_statement] = ACTIONS(86), + [anon_sym_goto] = ACTIONS(86), + [anon_sym_do] = ACTIONS(86), + [anon_sym_end] = ACTIONS(86), + [anon_sym_while] = ACTIONS(86), + [anon_sym_LPAREN] = ACTIONS(84), + [anon_sym_RPAREN] = ACTIONS(84), + [anon_sym_repeat] = ACTIONS(86), + [anon_sym_until] = ACTIONS(86), + [anon_sym_if] = ACTIONS(86), + [anon_sym_then] = ACTIONS(86), + [anon_sym_elseif] = ACTIONS(86), + [anon_sym_else] = ACTIONS(86), + [anon_sym_for] = ACTIONS(86), + [anon_sym_function] = ACTIONS(86), + [anon_sym_local] = ACTIONS(86), + [anon_sym_DOT] = ACTIONS(86), + [anon_sym_COLON] = ACTIONS(86), + [anon_sym_LT] = ACTIONS(86), + [anon_sym_GT] = ACTIONS(86), + [anon_sym_QMARK] = ACTIONS(84), + [aux_sym_include_statement_token1] = ACTIONS(84), + [anon_sym_DQUOTE] = ACTIONS(84), + [anon_sym_SQUOTE] = ACTIONS(84), + [anon_sym_LBRACK] = ACTIONS(84), + [anon_sym_RBRACK] = ACTIONS(84), + [anon_sym_LBRACE] = ACTIONS(84), + [anon_sym_RBRACE] = ACTIONS(84), + [anon_sym_or] = ACTIONS(86), + [anon_sym_and] = ACTIONS(86), + [anon_sym_LT_EQ] = ACTIONS(84), + [anon_sym_EQ_EQ] = ACTIONS(84), + [anon_sym_TILDE_EQ] = ACTIONS(84), + [anon_sym_BANG_EQ] = ACTIONS(84), + [anon_sym_GT_EQ] = ACTIONS(84), + [anon_sym_PIPE] = ACTIONS(86), + [anon_sym_TILDE] = ACTIONS(86), + [anon_sym_CARET_CARET] = ACTIONS(86), + [anon_sym_AMP] = ACTIONS(86), + [anon_sym_LT_LT] = ACTIONS(86), + [anon_sym_GT_GT] = ACTIONS(86), + [anon_sym_GT_GT_GT] = ACTIONS(86), + [anon_sym_LT_LT_GT] = ACTIONS(86), + [anon_sym_GT_GT_LT] = ACTIONS(86), + [anon_sym_PLUS] = ACTIONS(86), + [anon_sym_DASH] = ACTIONS(86), + [anon_sym_STAR] = ACTIONS(86), + [anon_sym_SLASH] = ACTIONS(86), + [anon_sym_SLASH_SLASH] = ACTIONS(84), + [anon_sym_PERCENT] = ACTIONS(86), + [anon_sym_BSLASH] = ACTIONS(86), + [anon_sym_DOT_DOT] = ACTIONS(86), + [anon_sym_CARET] = ACTIONS(86), + [anon_sym_DASH_DASH] = ACTIONS(3), + [sym__block_comment_start] = ACTIONS(5), + [sym__block_string_start] = ACTIONS(84), + }, + [6] = { + [sym_statement] = STATE(330), + [sym_empty_statement] = STATE(275), + [sym_assignment_statement] = STATE(275), + [sym__variable_assignment_varlist] = STATE(471), + [sym_compound_assignment_statement] = STATE(275), + [sym_label_statement] = STATE(275), + [sym_goto_statement] = STATE(275), + [sym_do_statement] = STATE(275), + [sym_while_statement] = STATE(275), + [sym_shorthand_while_statement] = STATE(275), + [sym_repeat_statement] = STATE(275), + [sym_if_statement] = STATE(275), + [sym_shorthand_if_statement] = STATE(275), + [sym_for_statement] = STATE(275), + [sym_declaration] = STATE(292), + [sym_function_declaration] = STATE(293), + [sym__local_function_declaration] = STATE(294), + [sym_variable_declaration] = STATE(295), + [sym_print_shorthand_statement] = STATE(275), + [sym_include_statement] = STATE(275), + [sym__prefix_expression] = STATE(335), + [sym_variable] = STATE(229), + [sym_bracket_index_expression] = STATE(2), + [sym_dot_index_expression] = STATE(2), + [sym_function_call] = STATE(227), + [sym_method_index_expression] = STATE(339), + [sym_parenthesized_expression] = STATE(342), + [sym_comment] = STATE(6), + [sym_identifier] = ACTIONS(9), + [anon_sym_SEMI] = ACTIONS(15), + [anon_sym_COLON_COLON] = ACTIONS(17), + [sym_break_statement] = ACTIONS(19), + [anon_sym_goto] = ACTIONS(21), + [anon_sym_do] = ACTIONS(23), + [anon_sym_while] = ACTIONS(88), + [anon_sym_LPAREN] = ACTIONS(63), + [anon_sym_repeat] = ACTIONS(29), + [anon_sym_if] = ACTIONS(90), + [anon_sym_then] = ACTIONS(70), + [anon_sym_for] = ACTIONS(33), + [anon_sym_function] = ACTIONS(35), + [anon_sym_local] = ACTIONS(37), + [anon_sym_DOT] = ACTIONS(70), + [anon_sym_COLON] = ACTIONS(70), + [anon_sym_LT] = ACTIONS(70), + [anon_sym_GT] = ACTIONS(70), + [anon_sym_QMARK] = ACTIONS(39), + [aux_sym_include_statement_token1] = ACTIONS(41), + [anon_sym_DQUOTE] = ACTIONS(82), + [anon_sym_SQUOTE] = ACTIONS(82), + [anon_sym_LBRACK] = ACTIONS(82), + [anon_sym_LBRACE] = ACTIONS(82), + [anon_sym_or] = ACTIONS(70), + [anon_sym_and] = ACTIONS(70), + [anon_sym_LT_EQ] = ACTIONS(82), + [anon_sym_EQ_EQ] = ACTIONS(82), + [anon_sym_TILDE_EQ] = ACTIONS(82), + [anon_sym_BANG_EQ] = ACTIONS(82), + [anon_sym_GT_EQ] = ACTIONS(82), + [anon_sym_PIPE] = ACTIONS(82), + [anon_sym_TILDE] = ACTIONS(70), + [anon_sym_CARET_CARET] = ACTIONS(82), + [anon_sym_AMP] = ACTIONS(82), + [anon_sym_LT_LT] = ACTIONS(70), + [anon_sym_GT_GT] = ACTIONS(70), + [anon_sym_GT_GT_GT] = ACTIONS(82), + [anon_sym_LT_LT_GT] = ACTIONS(82), + [anon_sym_GT_GT_LT] = ACTIONS(82), + [anon_sym_PLUS] = ACTIONS(82), + [anon_sym_DASH] = ACTIONS(70), + [anon_sym_STAR] = ACTIONS(82), + [anon_sym_SLASH] = ACTIONS(70), + [anon_sym_SLASH_SLASH] = ACTIONS(82), + [anon_sym_PERCENT] = ACTIONS(82), + [anon_sym_BSLASH] = ACTIONS(82), + [anon_sym_DOT_DOT] = ACTIONS(82), + [anon_sym_CARET] = ACTIONS(70), + [anon_sym_DASH_DASH] = ACTIONS(3), + [sym__block_comment_start] = ACTIONS(5), + [sym__block_string_start] = ACTIONS(82), + }, + [7] = { + [sym_statement] = STATE(321), + [sym_empty_statement] = STATE(304), + [sym_assignment_statement] = STATE(304), + [sym__variable_assignment_varlist] = STATE(449), + [sym_compound_assignment_statement] = STATE(304), + [sym_label_statement] = STATE(304), + [sym_goto_statement] = STATE(304), + [sym_do_statement] = STATE(304), + [sym_while_statement] = STATE(304), + [sym_shorthand_while_statement] = STATE(304), + [sym_repeat_statement] = STATE(304), + [sym_if_statement] = STATE(304), + [sym_shorthand_if_statement] = STATE(304), + [sym_for_statement] = STATE(304), + [sym_declaration] = STATE(311), + [sym_function_declaration] = STATE(317), + [sym__local_function_declaration] = STATE(318), + [sym_variable_declaration] = STATE(319), + [sym_print_shorthand_statement] = STATE(304), + [sym_include_statement] = STATE(304), + [sym__prefix_expression] = STATE(333), + [sym_variable] = STATE(230), + [sym_bracket_index_expression] = STATE(2), + [sym_dot_index_expression] = STATE(2), + [sym_function_call] = STATE(231), + [sym_method_index_expression] = STATE(336), + [sym_parenthesized_expression] = STATE(342), + [sym_comment] = STATE(7), + [sym_identifier] = ACTIONS(9), + [anon_sym_SEMI] = ACTIONS(51), + [anon_sym_COLON_COLON] = ACTIONS(53), + [sym_break_statement] = ACTIONS(55), + [anon_sym_goto] = ACTIONS(57), + [anon_sym_do] = ACTIONS(59), + [anon_sym_while] = ACTIONS(61), + [anon_sym_LPAREN] = ACTIONS(63), + [anon_sym_repeat] = ACTIONS(66), + [anon_sym_if] = ACTIONS(68), + [anon_sym_then] = ACTIONS(70), + [anon_sym_for] = ACTIONS(72), + [anon_sym_function] = ACTIONS(74), + [anon_sym_local] = ACTIONS(76), + [anon_sym_DOT] = ACTIONS(70), + [anon_sym_COLON] = ACTIONS(70), + [anon_sym_LT] = ACTIONS(70), + [anon_sym_GT] = ACTIONS(70), + [anon_sym_QMARK] = ACTIONS(78), + [aux_sym_include_statement_token1] = ACTIONS(80), + [anon_sym_DQUOTE] = ACTIONS(82), + [anon_sym_SQUOTE] = ACTIONS(82), + [anon_sym_LBRACK] = ACTIONS(82), + [anon_sym_LBRACE] = ACTIONS(82), + [anon_sym_or] = ACTIONS(70), + [anon_sym_and] = ACTIONS(70), + [anon_sym_LT_EQ] = ACTIONS(82), + [anon_sym_EQ_EQ] = ACTIONS(82), + [anon_sym_TILDE_EQ] = ACTIONS(82), + [anon_sym_BANG_EQ] = ACTIONS(82), + [anon_sym_GT_EQ] = ACTIONS(82), + [anon_sym_PIPE] = ACTIONS(82), + [anon_sym_TILDE] = ACTIONS(70), + [anon_sym_CARET_CARET] = ACTIONS(82), + [anon_sym_AMP] = ACTIONS(82), + [anon_sym_LT_LT] = ACTIONS(70), + [anon_sym_GT_GT] = ACTIONS(70), + [anon_sym_GT_GT_GT] = ACTIONS(82), + [anon_sym_LT_LT_GT] = ACTIONS(82), + [anon_sym_GT_GT_LT] = ACTIONS(82), + [anon_sym_PLUS] = ACTIONS(82), + [anon_sym_DASH] = ACTIONS(70), + [anon_sym_STAR] = ACTIONS(82), + [anon_sym_SLASH] = ACTIONS(70), + [anon_sym_SLASH_SLASH] = ACTIONS(82), + [anon_sym_PERCENT] = ACTIONS(82), + [anon_sym_BSLASH] = ACTIONS(82), + [anon_sym_DOT_DOT] = ACTIONS(82), + [anon_sym_CARET] = ACTIONS(70), + [anon_sym_DASH_DASH] = ACTIONS(3), + [sym__block_comment_start] = ACTIONS(5), + [sym__block_string_start] = ACTIONS(82), + }, + [8] = { + [sym_statement] = STATE(284), + [sym_empty_statement] = STATE(275), + [sym_assignment_statement] = STATE(275), + [sym__variable_assignment_varlist] = STATE(471), + [sym_compound_assignment_statement] = STATE(275), + [sym_label_statement] = STATE(275), + [sym_goto_statement] = STATE(275), + [sym_do_statement] = STATE(275), + [sym_while_statement] = STATE(275), + [sym_shorthand_while_statement] = STATE(275), + [sym_repeat_statement] = STATE(275), + [sym_if_statement] = STATE(275), + [sym_shorthand_if_statement] = STATE(275), + [sym_for_statement] = STATE(275), + [sym_declaration] = STATE(292), + [sym_function_declaration] = STATE(293), + [sym__local_function_declaration] = STATE(294), + [sym_variable_declaration] = STATE(295), + [sym_print_shorthand_statement] = STATE(275), + [sym_include_statement] = STATE(275), + [sym__prefix_expression] = STATE(335), + [sym_variable] = STATE(229), + [sym_bracket_index_expression] = STATE(2), + [sym_dot_index_expression] = STATE(2), + [sym_function_call] = STATE(227), + [sym_method_index_expression] = STATE(339), + [sym_parenthesized_expression] = STATE(342), + [sym_comment] = STATE(8), + [sym_identifier] = ACTIONS(9), + [anon_sym_SEMI] = ACTIONS(15), + [anon_sym_COLON_COLON] = ACTIONS(17), + [sym_break_statement] = ACTIONS(19), + [anon_sym_goto] = ACTIONS(21), + [anon_sym_do] = ACTIONS(92), + [anon_sym_while] = ACTIONS(25), + [anon_sym_LPAREN] = ACTIONS(63), + [anon_sym_repeat] = ACTIONS(29), + [anon_sym_if] = ACTIONS(31), + [anon_sym_for] = ACTIONS(33), + [anon_sym_function] = ACTIONS(35), + [anon_sym_local] = ACTIONS(37), + [anon_sym_DOT] = ACTIONS(70), + [anon_sym_COLON] = ACTIONS(70), + [anon_sym_LT] = ACTIONS(70), + [anon_sym_GT] = ACTIONS(70), + [anon_sym_QMARK] = ACTIONS(39), + [aux_sym_include_statement_token1] = ACTIONS(41), + [anon_sym_DQUOTE] = ACTIONS(82), + [anon_sym_SQUOTE] = ACTIONS(82), + [anon_sym_LBRACK] = ACTIONS(82), + [anon_sym_LBRACE] = ACTIONS(82), + [anon_sym_or] = ACTIONS(70), + [anon_sym_and] = ACTIONS(70), + [anon_sym_LT_EQ] = ACTIONS(82), + [anon_sym_EQ_EQ] = ACTIONS(82), + [anon_sym_TILDE_EQ] = ACTIONS(82), + [anon_sym_BANG_EQ] = ACTIONS(82), + [anon_sym_GT_EQ] = ACTIONS(82), + [anon_sym_PIPE] = ACTIONS(82), + [anon_sym_TILDE] = ACTIONS(70), + [anon_sym_CARET_CARET] = ACTIONS(82), + [anon_sym_AMP] = ACTIONS(82), + [anon_sym_LT_LT] = ACTIONS(70), + [anon_sym_GT_GT] = ACTIONS(70), + [anon_sym_GT_GT_GT] = ACTIONS(82), + [anon_sym_LT_LT_GT] = ACTIONS(82), + [anon_sym_GT_GT_LT] = ACTIONS(82), + [anon_sym_PLUS] = ACTIONS(82), + [anon_sym_DASH] = ACTIONS(70), + [anon_sym_STAR] = ACTIONS(82), + [anon_sym_SLASH] = ACTIONS(70), + [anon_sym_SLASH_SLASH] = ACTIONS(82), + [anon_sym_PERCENT] = ACTIONS(82), + [anon_sym_BSLASH] = ACTIONS(82), + [anon_sym_DOT_DOT] = ACTIONS(82), + [anon_sym_CARET] = ACTIONS(70), + [anon_sym_DASH_DASH] = ACTIONS(3), + [sym__block_comment_start] = ACTIONS(5), + [sym__block_string_start] = ACTIONS(82), + }, + [9] = { + [sym_statement] = STATE(284), + [sym_empty_statement] = STATE(275), + [sym_assignment_statement] = STATE(275), + [sym__variable_assignment_varlist] = STATE(471), + [sym_compound_assignment_statement] = STATE(275), + [sym_label_statement] = STATE(275), + [sym_goto_statement] = STATE(275), + [sym_do_statement] = STATE(275), + [sym_while_statement] = STATE(275), + [sym_shorthand_while_statement] = STATE(275), + [sym_repeat_statement] = STATE(275), + [sym_if_statement] = STATE(275), + [sym_shorthand_if_statement] = STATE(275), + [sym_for_statement] = STATE(275), + [sym_declaration] = STATE(292), + [sym_function_declaration] = STATE(293), + [sym__local_function_declaration] = STATE(294), + [sym_variable_declaration] = STATE(295), + [sym_print_shorthand_statement] = STATE(275), + [sym_include_statement] = STATE(275), + [sym__prefix_expression] = STATE(335), + [sym_variable] = STATE(229), + [sym_bracket_index_expression] = STATE(2), + [sym_dot_index_expression] = STATE(2), + [sym_function_call] = STATE(227), + [sym_method_index_expression] = STATE(339), + [sym_parenthesized_expression] = STATE(342), + [sym_comment] = STATE(9), + [sym_identifier] = ACTIONS(9), + [anon_sym_SEMI] = ACTIONS(15), + [anon_sym_COLON_COLON] = ACTIONS(17), + [sym_break_statement] = ACTIONS(19), + [anon_sym_goto] = ACTIONS(21), + [anon_sym_do] = ACTIONS(92), + [anon_sym_while] = ACTIONS(88), + [anon_sym_LPAREN] = ACTIONS(63), + [anon_sym_repeat] = ACTIONS(29), + [anon_sym_if] = ACTIONS(90), + [anon_sym_for] = ACTIONS(33), + [anon_sym_function] = ACTIONS(35), + [anon_sym_local] = ACTIONS(37), + [anon_sym_DOT] = ACTIONS(70), + [anon_sym_COLON] = ACTIONS(70), + [anon_sym_LT] = ACTIONS(70), + [anon_sym_GT] = ACTIONS(70), + [anon_sym_QMARK] = ACTIONS(39), + [aux_sym_include_statement_token1] = ACTIONS(41), + [anon_sym_DQUOTE] = ACTIONS(82), + [anon_sym_SQUOTE] = ACTIONS(82), + [anon_sym_LBRACK] = ACTIONS(82), + [anon_sym_LBRACE] = ACTIONS(82), + [anon_sym_or] = ACTIONS(70), + [anon_sym_and] = ACTIONS(70), + [anon_sym_LT_EQ] = ACTIONS(82), + [anon_sym_EQ_EQ] = ACTIONS(82), + [anon_sym_TILDE_EQ] = ACTIONS(82), + [anon_sym_BANG_EQ] = ACTIONS(82), + [anon_sym_GT_EQ] = ACTIONS(82), + [anon_sym_PIPE] = ACTIONS(82), + [anon_sym_TILDE] = ACTIONS(70), + [anon_sym_CARET_CARET] = ACTIONS(82), + [anon_sym_AMP] = ACTIONS(82), + [anon_sym_LT_LT] = ACTIONS(70), + [anon_sym_GT_GT] = ACTIONS(70), + [anon_sym_GT_GT_GT] = ACTIONS(82), + [anon_sym_LT_LT_GT] = ACTIONS(82), + [anon_sym_GT_GT_LT] = ACTIONS(82), + [anon_sym_PLUS] = ACTIONS(82), + [anon_sym_DASH] = ACTIONS(70), + [anon_sym_STAR] = ACTIONS(82), + [anon_sym_SLASH] = ACTIONS(70), + [anon_sym_SLASH_SLASH] = ACTIONS(82), + [anon_sym_PERCENT] = ACTIONS(82), + [anon_sym_BSLASH] = ACTIONS(82), + [anon_sym_DOT_DOT] = ACTIONS(82), + [anon_sym_CARET] = ACTIONS(70), + [anon_sym_DASH_DASH] = ACTIONS(3), + [sym__block_comment_start] = ACTIONS(5), + [sym__block_string_start] = ACTIONS(82), + }, + [10] = { + [sym_statement] = STATE(298), + [sym_empty_statement] = STATE(304), + [sym_assignment_statement] = STATE(304), + [sym__variable_assignment_varlist] = STATE(449), + [sym_compound_assignment_statement] = STATE(304), + [sym_label_statement] = STATE(304), + [sym_goto_statement] = STATE(304), + [sym_do_statement] = STATE(304), + [sym_while_statement] = STATE(304), + [sym_shorthand_while_statement] = STATE(304), + [sym_repeat_statement] = STATE(304), + [sym_if_statement] = STATE(304), + [sym_shorthand_if_statement] = STATE(304), + [sym_for_statement] = STATE(304), + [sym_declaration] = STATE(311), + [sym_function_declaration] = STATE(317), + [sym__local_function_declaration] = STATE(318), + [sym_variable_declaration] = STATE(319), + [sym_print_shorthand_statement] = STATE(304), + [sym_include_statement] = STATE(304), + [sym__prefix_expression] = STATE(333), + [sym_variable] = STATE(230), + [sym_bracket_index_expression] = STATE(2), + [sym_dot_index_expression] = STATE(2), + [sym_function_call] = STATE(231), + [sym_method_index_expression] = STATE(336), + [sym_parenthesized_expression] = STATE(342), + [sym_comment] = STATE(10), + [sym_identifier] = ACTIONS(9), + [anon_sym_SEMI] = ACTIONS(51), + [anon_sym_COLON_COLON] = ACTIONS(53), + [sym_break_statement] = ACTIONS(55), + [anon_sym_goto] = ACTIONS(57), + [anon_sym_do] = ACTIONS(95), + [anon_sym_while] = ACTIONS(61), + [anon_sym_LPAREN] = ACTIONS(63), + [anon_sym_repeat] = ACTIONS(66), + [anon_sym_if] = ACTIONS(68), + [anon_sym_for] = ACTIONS(72), + [anon_sym_function] = ACTIONS(74), + [anon_sym_local] = ACTIONS(76), + [anon_sym_DOT] = ACTIONS(70), + [anon_sym_COLON] = ACTIONS(70), + [anon_sym_LT] = ACTIONS(70), + [anon_sym_GT] = ACTIONS(70), + [anon_sym_QMARK] = ACTIONS(78), + [aux_sym_include_statement_token1] = ACTIONS(80), + [anon_sym_DQUOTE] = ACTIONS(82), + [anon_sym_SQUOTE] = ACTIONS(82), + [anon_sym_LBRACK] = ACTIONS(82), + [anon_sym_LBRACE] = ACTIONS(82), + [anon_sym_or] = ACTIONS(70), + [anon_sym_and] = ACTIONS(70), + [anon_sym_LT_EQ] = ACTIONS(82), + [anon_sym_EQ_EQ] = ACTIONS(82), + [anon_sym_TILDE_EQ] = ACTIONS(82), + [anon_sym_BANG_EQ] = ACTIONS(82), + [anon_sym_GT_EQ] = ACTIONS(82), + [anon_sym_PIPE] = ACTIONS(82), + [anon_sym_TILDE] = ACTIONS(70), + [anon_sym_CARET_CARET] = ACTIONS(82), + [anon_sym_AMP] = ACTIONS(82), + [anon_sym_LT_LT] = ACTIONS(70), + [anon_sym_GT_GT] = ACTIONS(70), + [anon_sym_GT_GT_GT] = ACTIONS(82), + [anon_sym_LT_LT_GT] = ACTIONS(82), + [anon_sym_GT_GT_LT] = ACTIONS(82), + [anon_sym_PLUS] = ACTIONS(82), + [anon_sym_DASH] = ACTIONS(70), + [anon_sym_STAR] = ACTIONS(82), + [anon_sym_SLASH] = ACTIONS(70), + [anon_sym_SLASH_SLASH] = ACTIONS(82), + [anon_sym_PERCENT] = ACTIONS(82), + [anon_sym_BSLASH] = ACTIONS(82), + [anon_sym_DOT_DOT] = ACTIONS(82), + [anon_sym_CARET] = ACTIONS(70), + [anon_sym_DASH_DASH] = ACTIONS(3), + [sym__block_comment_start] = ACTIONS(5), + [sym__block_string_start] = ACTIONS(82), + }, +}; + +static const uint16_t ts_small_parse_table[] = { + [0] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(11), 1, + sym_comment, + ACTIONS(100), 28, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(98), 32, + sym__block_string_start, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [74] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(12), 1, + sym_comment, + ACTIONS(104), 28, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(102), 32, + sym__block_string_start, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [148] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(13), 1, + sym_comment, + ACTIONS(108), 28, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(106), 32, + sym__block_string_start, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [222] = 7, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(14), 1, + sym_comment, + ACTIONS(116), 2, + anon_sym_DOT, + anon_sym_COLON, + ACTIONS(114), 6, + sym__block_string_start, + anon_sym_LPAREN, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_LBRACE, + ACTIONS(110), 26, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_RBRACK, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + ACTIONS(112), 26, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + [300] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(15), 1, + sym_comment, + ACTIONS(70), 28, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(82), 32, + sym__block_string_start, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [374] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(16), 1, + sym_comment, + ACTIONS(120), 28, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(118), 32, + sym__block_string_start, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [448] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(17), 1, + sym_comment, + ACTIONS(124), 28, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(122), 32, + sym__block_string_start, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [522] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(18), 1, + sym_comment, + ACTIONS(128), 28, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(126), 32, + sym__block_string_start, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [596] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(19), 1, + sym_comment, + ACTIONS(132), 28, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(130), 32, + sym__block_string_start, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [670] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(20), 1, + sym_comment, + ACTIONS(136), 28, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(134), 32, + sym__block_string_start, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [744] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(21), 1, + sym_comment, + ACTIONS(140), 28, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(138), 32, + sym__block_string_start, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [818] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(22), 1, + sym_comment, + ACTIONS(140), 28, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(138), 32, + sym__block_string_start, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [892] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(23), 1, + sym_comment, + ACTIONS(144), 28, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(142), 32, + sym__block_string_start, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [966] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(24), 1, + sym_comment, + ACTIONS(148), 28, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(146), 32, + sym__block_string_start, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [1040] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(25), 1, + sym_comment, + ACTIONS(124), 26, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(122), 29, + sym__block_string_start, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_LBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [1109] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(26), 1, + sym_comment, + ACTIONS(136), 26, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(134), 29, + sym__block_string_start, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_LBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [1178] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(27), 1, + sym_comment, + ACTIONS(45), 26, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(43), 29, + sym__block_string_start, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_LBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [1247] = 7, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(28), 1, + sym_comment, + ACTIONS(116), 2, + anon_sym_DOT, + anon_sym_COLON, + ACTIONS(114), 6, + sym__block_string_start, + anon_sym_LPAREN, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_LBRACE, + ACTIONS(110), 23, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + ACTIONS(112), 24, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + [1320] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(29), 1, + sym_comment, + ACTIONS(104), 26, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(102), 29, + sym__block_string_start, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_LBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [1389] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(30), 1, + sym_comment, + ACTIONS(100), 26, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(98), 29, + sym__block_string_start, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_LBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [1458] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(31), 1, + sym_comment, + ACTIONS(70), 26, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(82), 29, + sym__block_string_start, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_LBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [1527] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(32), 1, + sym_comment, + ACTIONS(108), 26, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(106), 29, + sym__block_string_start, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_LBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [1596] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(33), 1, + sym_comment, + ACTIONS(49), 26, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(47), 29, + sym__block_string_start, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_LBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [1665] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(34), 1, + sym_comment, + ACTIONS(120), 26, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(118), 29, + sym__block_string_start, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_LBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [1734] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(35), 1, + sym_comment, + ACTIONS(86), 26, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(84), 29, + sym__block_string_start, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_LBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [1803] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(36), 1, + sym_comment, + ACTIONS(148), 26, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(146), 29, + sym__block_string_start, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_LBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [1872] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(37), 1, + sym_comment, + ACTIONS(140), 26, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(138), 29, + sym__block_string_start, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_LBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [1941] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(38), 1, + sym_comment, + ACTIONS(140), 26, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(138), 29, + sym__block_string_start, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_LBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [2010] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(39), 1, + sym_comment, + ACTIONS(144), 26, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(142), 29, + sym__block_string_start, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_LBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [2079] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(40), 1, + sym_comment, + ACTIONS(128), 26, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(126), 29, + sym__block_string_start, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_LBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [2148] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(41), 1, + sym_comment, + ACTIONS(132), 26, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(130), 29, + sym__block_string_start, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_LBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [2217] = 14, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + STATE(42), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(150), 17, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_RBRACK, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + ACTIONS(152), 21, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + sym_identifier, + [2302] = 13, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + STATE(43), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(150), 18, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_RBRACK, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + ACTIONS(152), 21, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + sym_identifier, + [2385] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(170), 1, + anon_sym_CARET, + STATE(44), 1, + sym_comment, + ACTIONS(152), 25, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + sym_identifier, + ACTIONS(150), 27, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_RBRACK, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [2454] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(45), 1, + sym_comment, + ACTIONS(128), 26, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(126), 27, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_RBRACK, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [2521] = 8, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(170), 1, + anon_sym_CARET, + STATE(46), 1, + sym_comment, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(150), 23, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_RBRACK, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_DOT_DOT, + ACTIONS(152), 24, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + sym_identifier, + [2594] = 11, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + STATE(47), 1, + sym_comment, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(150), 21, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_RBRACK, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(152), 23, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_identifier, + [2673] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(170), 1, + anon_sym_CARET, + STATE(48), 1, + sym_comment, + ACTIONS(152), 25, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + sym_identifier, + ACTIONS(150), 27, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_RBRACK, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [2742] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(49), 1, + sym_comment, + ACTIONS(140), 26, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(138), 27, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_RBRACK, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [2809] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(50), 1, + sym_comment, + ACTIONS(140), 26, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(138), 27, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_RBRACK, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [2876] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(51), 1, + sym_comment, + ACTIONS(174), 26, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(172), 27, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_RBRACK, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [2943] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(52), 1, + sym_comment, + ACTIONS(178), 26, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(176), 27, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_RBRACK, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [3010] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(53), 1, + sym_comment, + ACTIONS(132), 26, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(130), 27, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_RBRACK, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [3077] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(54), 1, + sym_comment, + ACTIONS(136), 26, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(134), 27, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_RBRACK, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [3144] = 17, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + STATE(55), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(150), 15, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_RBRACK, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + ACTIONS(152), 20, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + sym_identifier, + [3235] = 20, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(188), 1, + anon_sym_and, + STATE(56), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + ACTIONS(150), 10, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_RBRACK, + anon_sym_RBRACE, + ACTIONS(152), 17, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_or, + sym_identifier, + [3332] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(57), 1, + sym_comment, + ACTIONS(112), 26, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(110), 27, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_RBRACK, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [3399] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(58), 1, + sym_comment, + ACTIONS(124), 26, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(122), 27, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_RBRACK, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [3466] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(59), 1, + sym_comment, + ACTIONS(144), 26, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(142), 27, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_RBRACK, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [3533] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(60), 1, + sym_comment, + ACTIONS(194), 26, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + ACTIONS(192), 27, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_RBRACK, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [3600] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(170), 1, + anon_sym_CARET, + STATE(61), 1, + sym_comment, + ACTIONS(198), 25, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + sym_identifier, + ACTIONS(196), 27, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_RBRACK, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [3669] = 19, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + STATE(62), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + ACTIONS(150), 10, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_RBRACK, + anon_sym_RBRACE, + ACTIONS(152), 18, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_or, + anon_sym_and, + sym_identifier, + [3764] = 11, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + STATE(63), 1, + sym_comment, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(150), 21, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_RBRACK, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(152), 23, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_identifier, + [3843] = 16, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + STATE(64), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(150), 16, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_RBRACK, + anon_sym_RBRACE, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + ACTIONS(152), 20, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_then, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + sym_identifier, + [3932] = 41, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(13), 1, + anon_sym_return, + ACTIONS(15), 1, + anon_sym_SEMI, + ACTIONS(17), 1, + anon_sym_COLON_COLON, + ACTIONS(19), 1, + sym_break_statement, + ACTIONS(21), 1, + anon_sym_goto, + ACTIONS(23), 1, + anon_sym_do, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(29), 1, + anon_sym_repeat, + ACTIONS(33), 1, + anon_sym_for, + ACTIONS(35), 1, + anon_sym_function, + ACTIONS(37), 1, + anon_sym_local, + ACTIONS(39), 1, + anon_sym_QMARK, + ACTIONS(41), 1, + aux_sym_include_statement_token1, + ACTIONS(88), 1, + anon_sym_while, + ACTIONS(90), 1, + anon_sym_if, + ACTIONS(200), 1, + anon_sym_end, + ACTIONS(202), 1, + anon_sym_elseif, + ACTIONS(204), 1, + anon_sym_else, + STATE(65), 1, + sym_comment, + STATE(74), 1, + aux_sym_chunk_repeat1, + STATE(227), 1, + sym_function_call, + STATE(229), 1, + sym_variable, + STATE(286), 1, + sym_statement, + STATE(292), 1, + sym_declaration, + STATE(293), 1, + sym_function_declaration, + STATE(294), 1, + sym__local_function_declaration, + STATE(295), 1, + sym_variable_declaration, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + STATE(342), 1, + sym_parenthesized_expression, + STATE(344), 1, + aux_sym_if_statement_repeat1, + STATE(346), 1, + sym__block, + STATE(381), 1, + sym_return_statement, + STATE(405), 1, + sym_elseif_statement, + STATE(471), 1, + sym__variable_assignment_varlist, + STATE(476), 1, + sym_else_statement, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + STATE(275), 14, + sym_empty_statement, + sym_assignment_statement, + sym_compound_assignment_statement, + sym_label_statement, + sym_goto_statement, + sym_do_statement, + sym_while_statement, + sym_shorthand_while_statement, + sym_repeat_statement, + sym_if_statement, + sym_shorthand_if_statement, + sym_for_statement, + sym_print_shorthand_statement, + sym_include_statement, + [4070] = 41, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(13), 1, + anon_sym_return, + ACTIONS(15), 1, + anon_sym_SEMI, + ACTIONS(17), 1, + anon_sym_COLON_COLON, + ACTIONS(19), 1, + sym_break_statement, + ACTIONS(21), 1, + anon_sym_goto, + ACTIONS(23), 1, + anon_sym_do, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(29), 1, + anon_sym_repeat, + ACTIONS(33), 1, + anon_sym_for, + ACTIONS(35), 1, + anon_sym_function, + ACTIONS(37), 1, + anon_sym_local, + ACTIONS(39), 1, + anon_sym_QMARK, + ACTIONS(41), 1, + aux_sym_include_statement_token1, + ACTIONS(88), 1, + anon_sym_while, + ACTIONS(90), 1, + anon_sym_if, + ACTIONS(202), 1, + anon_sym_elseif, + ACTIONS(204), 1, + anon_sym_else, + ACTIONS(206), 1, + anon_sym_end, + STATE(66), 1, + sym_comment, + STATE(74), 1, + aux_sym_chunk_repeat1, + STATE(227), 1, + sym_function_call, + STATE(229), 1, + sym_variable, + STATE(286), 1, + sym_statement, + STATE(292), 1, + sym_declaration, + STATE(293), 1, + sym_function_declaration, + STATE(294), 1, + sym__local_function_declaration, + STATE(295), 1, + sym_variable_declaration, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + STATE(342), 1, + sym_parenthesized_expression, + STATE(348), 1, + sym__block, + STATE(349), 1, + aux_sym_if_statement_repeat1, + STATE(381), 1, + sym_return_statement, + STATE(405), 1, + sym_elseif_statement, + STATE(436), 1, + sym_else_statement, + STATE(471), 1, + sym__variable_assignment_varlist, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + STATE(275), 14, + sym_empty_statement, + sym_assignment_statement, + sym_compound_assignment_statement, + sym_label_statement, + sym_goto_statement, + sym_do_statement, + sym_while_statement, + sym_shorthand_while_statement, + sym_repeat_statement, + sym_if_statement, + sym_shorthand_if_statement, + sym_for_statement, + sym_print_shorthand_statement, + sym_include_statement, + [4208] = 23, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(188), 1, + anon_sym_and, + ACTIONS(212), 1, + anon_sym_COMMA, + ACTIONS(214), 1, + anon_sym_or, + STATE(67), 1, + sym_comment, + STATE(253), 1, + aux_sym_print_shorthand_statement_repeat1, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + ACTIONS(208), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(210), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [4308] = 23, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(188), 1, + anon_sym_and, + ACTIONS(214), 1, + anon_sym_or, + ACTIONS(220), 1, + anon_sym_COMMA, + STATE(68), 1, + sym_comment, + STATE(247), 1, + aux_sym__variable_assignment_explist_repeat1, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + ACTIONS(216), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(218), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [4408] = 23, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(222), 1, + anon_sym_COMMA, + ACTIONS(226), 1, + anon_sym_or, + ACTIONS(228), 1, + anon_sym_and, + ACTIONS(232), 1, + anon_sym_PIPE, + ACTIONS(234), 1, + anon_sym_TILDE, + ACTIONS(236), 1, + anon_sym_CARET_CARET, + ACTIONS(238), 1, + anon_sym_AMP, + ACTIONS(244), 1, + anon_sym_PLUS, + ACTIONS(246), 1, + anon_sym_DASH, + ACTIONS(250), 1, + anon_sym_SLASH, + ACTIONS(252), 1, + anon_sym_DOT_DOT, + ACTIONS(254), 1, + anon_sym_CARET, + STATE(69), 1, + sym_comment, + STATE(260), 1, + aux_sym_print_shorthand_statement_repeat1, + ACTIONS(224), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(240), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(242), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(248), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(230), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + ACTIONS(208), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(210), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [4507] = 23, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(226), 1, + anon_sym_or, + ACTIONS(228), 1, + anon_sym_and, + ACTIONS(232), 1, + anon_sym_PIPE, + ACTIONS(234), 1, + anon_sym_TILDE, + ACTIONS(236), 1, + anon_sym_CARET_CARET, + ACTIONS(238), 1, + anon_sym_AMP, + ACTIONS(244), 1, + anon_sym_PLUS, + ACTIONS(246), 1, + anon_sym_DASH, + ACTIONS(250), 1, + anon_sym_SLASH, + ACTIONS(252), 1, + anon_sym_DOT_DOT, + ACTIONS(254), 1, + anon_sym_CARET, + ACTIONS(256), 1, + anon_sym_COMMA, + STATE(70), 1, + sym_comment, + STATE(263), 1, + aux_sym__variable_assignment_explist_repeat1, + ACTIONS(224), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(240), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(242), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(248), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(230), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + ACTIONS(216), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(218), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [4606] = 21, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(188), 1, + anon_sym_and, + ACTIONS(214), 1, + anon_sym_or, + STATE(71), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + ACTIONS(258), 7, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(260), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [4701] = 21, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(188), 1, + anon_sym_and, + ACTIONS(214), 1, + anon_sym_or, + STATE(72), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + ACTIONS(262), 7, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(264), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [4796] = 36, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(13), 1, + anon_sym_return, + ACTIONS(15), 1, + anon_sym_SEMI, + ACTIONS(17), 1, + anon_sym_COLON_COLON, + ACTIONS(19), 1, + sym_break_statement, + ACTIONS(21), 1, + anon_sym_goto, + ACTIONS(23), 1, + anon_sym_do, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(29), 1, + anon_sym_repeat, + ACTIONS(33), 1, + anon_sym_for, + ACTIONS(35), 1, + anon_sym_function, + ACTIONS(37), 1, + anon_sym_local, + ACTIONS(39), 1, + anon_sym_QMARK, + ACTIONS(41), 1, + aux_sym_include_statement_token1, + ACTIONS(88), 1, + anon_sym_while, + ACTIONS(90), 1, + anon_sym_if, + STATE(73), 1, + sym_comment, + STATE(74), 1, + aux_sym_chunk_repeat1, + STATE(227), 1, + sym_function_call, + STATE(229), 1, + sym_variable, + STATE(286), 1, + sym_statement, + STATE(292), 1, + sym_declaration, + STATE(293), 1, + sym_function_declaration, + STATE(294), 1, + sym__local_function_declaration, + STATE(295), 1, + sym_variable_declaration, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + STATE(342), 1, + sym_parenthesized_expression, + STATE(381), 1, + sym_return_statement, + STATE(409), 1, + sym__block, + STATE(471), 1, + sym__variable_assignment_varlist, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(266), 3, + anon_sym_end, + anon_sym_elseif, + anon_sym_else, + STATE(275), 14, + sym_empty_statement, + sym_assignment_statement, + sym_compound_assignment_statement, + sym_label_statement, + sym_goto_statement, + sym_do_statement, + sym_while_statement, + sym_shorthand_while_statement, + sym_repeat_statement, + sym_if_statement, + sym_shorthand_if_statement, + sym_for_statement, + sym_print_shorthand_statement, + sym_include_statement, + [4921] = 35, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(13), 1, + anon_sym_return, + ACTIONS(15), 1, + anon_sym_SEMI, + ACTIONS(17), 1, + anon_sym_COLON_COLON, + ACTIONS(19), 1, + sym_break_statement, + ACTIONS(21), 1, + anon_sym_goto, + ACTIONS(23), 1, + anon_sym_do, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(29), 1, + anon_sym_repeat, + ACTIONS(33), 1, + anon_sym_for, + ACTIONS(35), 1, + anon_sym_function, + ACTIONS(37), 1, + anon_sym_local, + ACTIONS(39), 1, + anon_sym_QMARK, + ACTIONS(41), 1, + aux_sym_include_statement_token1, + ACTIONS(88), 1, + anon_sym_while, + ACTIONS(90), 1, + anon_sym_if, + STATE(74), 1, + sym_comment, + STATE(119), 1, + aux_sym_chunk_repeat1, + STATE(227), 1, + sym_function_call, + STATE(229), 1, + sym_variable, + STATE(286), 1, + sym_statement, + STATE(292), 1, + sym_declaration, + STATE(293), 1, + sym_function_declaration, + STATE(294), 1, + sym__local_function_declaration, + STATE(295), 1, + sym_variable_declaration, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + STATE(342), 1, + sym_parenthesized_expression, + STATE(382), 1, + sym_return_statement, + STATE(471), 1, + sym__variable_assignment_varlist, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(268), 3, + anon_sym_end, + anon_sym_elseif, + anon_sym_else, + STATE(275), 14, + sym_empty_statement, + sym_assignment_statement, + sym_compound_assignment_statement, + sym_label_statement, + sym_goto_statement, + sym_do_statement, + sym_while_statement, + sym_shorthand_while_statement, + sym_repeat_statement, + sym_if_statement, + sym_shorthand_if_statement, + sym_for_statement, + sym_print_shorthand_statement, + sym_include_statement, + [5043] = 21, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(188), 1, + anon_sym_and, + ACTIONS(214), 1, + anon_sym_or, + STATE(75), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + ACTIONS(270), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(272), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [5137] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(76), 1, + sym_comment, + ACTIONS(172), 24, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + ACTIONS(174), 24, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + [5199] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(254), 1, + anon_sym_CARET, + STATE(77), 1, + sym_comment, + ACTIONS(198), 23, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + sym_identifier, + ACTIONS(196), 24, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [5263] = 21, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(188), 1, + anon_sym_and, + ACTIONS(214), 1, + anon_sym_or, + STATE(78), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + ACTIONS(274), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(276), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [5357] = 21, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(188), 1, + anon_sym_and, + ACTIONS(214), 1, + anon_sym_or, + STATE(79), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + ACTIONS(278), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(280), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [5451] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(80), 1, + sym_comment, + ACTIONS(176), 24, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + ACTIONS(178), 24, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + [5513] = 17, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(232), 1, + anon_sym_PIPE, + ACTIONS(234), 1, + anon_sym_TILDE, + ACTIONS(236), 1, + anon_sym_CARET_CARET, + ACTIONS(238), 1, + anon_sym_AMP, + ACTIONS(244), 1, + anon_sym_PLUS, + ACTIONS(246), 1, + anon_sym_DASH, + ACTIONS(250), 1, + anon_sym_SLASH, + ACTIONS(252), 1, + anon_sym_DOT_DOT, + ACTIONS(254), 1, + anon_sym_CARET, + STATE(81), 1, + sym_comment, + ACTIONS(240), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(242), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(248), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(150), 12, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + ACTIONS(152), 18, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + sym_identifier, + [5599] = 20, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(228), 1, + anon_sym_and, + ACTIONS(232), 1, + anon_sym_PIPE, + ACTIONS(234), 1, + anon_sym_TILDE, + ACTIONS(236), 1, + anon_sym_CARET_CARET, + ACTIONS(238), 1, + anon_sym_AMP, + ACTIONS(244), 1, + anon_sym_PLUS, + ACTIONS(246), 1, + anon_sym_DASH, + ACTIONS(250), 1, + anon_sym_SLASH, + ACTIONS(252), 1, + anon_sym_DOT_DOT, + ACTIONS(254), 1, + anon_sym_CARET, + STATE(82), 1, + sym_comment, + ACTIONS(224), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(240), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(242), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(248), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(230), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + ACTIONS(150), 7, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(152), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_or, + sym_identifier, + [5691] = 19, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(232), 1, + anon_sym_PIPE, + ACTIONS(234), 1, + anon_sym_TILDE, + ACTIONS(236), 1, + anon_sym_CARET_CARET, + ACTIONS(238), 1, + anon_sym_AMP, + ACTIONS(244), 1, + anon_sym_PLUS, + ACTIONS(246), 1, + anon_sym_DASH, + ACTIONS(250), 1, + anon_sym_SLASH, + ACTIONS(252), 1, + anon_sym_DOT_DOT, + ACTIONS(254), 1, + anon_sym_CARET, + STATE(83), 1, + sym_comment, + ACTIONS(224), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(240), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(242), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(248), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(230), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + ACTIONS(150), 7, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(152), 16, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_or, + anon_sym_and, + sym_identifier, + [5781] = 16, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(234), 1, + anon_sym_TILDE, + ACTIONS(236), 1, + anon_sym_CARET_CARET, + ACTIONS(238), 1, + anon_sym_AMP, + ACTIONS(244), 1, + anon_sym_PLUS, + ACTIONS(246), 1, + anon_sym_DASH, + ACTIONS(250), 1, + anon_sym_SLASH, + ACTIONS(252), 1, + anon_sym_DOT_DOT, + ACTIONS(254), 1, + anon_sym_CARET, + STATE(84), 1, + sym_comment, + ACTIONS(240), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(242), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(248), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(150), 13, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + ACTIONS(152), 18, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + sym_identifier, + [5865] = 14, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(238), 1, + anon_sym_AMP, + ACTIONS(244), 1, + anon_sym_PLUS, + ACTIONS(246), 1, + anon_sym_DASH, + ACTIONS(250), 1, + anon_sym_SLASH, + ACTIONS(252), 1, + anon_sym_DOT_DOT, + ACTIONS(254), 1, + anon_sym_CARET, + STATE(85), 1, + sym_comment, + ACTIONS(240), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(242), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(248), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(150), 14, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + ACTIONS(152), 19, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + sym_identifier, + [5945] = 13, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(244), 1, + anon_sym_PLUS, + ACTIONS(246), 1, + anon_sym_DASH, + ACTIONS(250), 1, + anon_sym_SLASH, + ACTIONS(252), 1, + anon_sym_DOT_DOT, + ACTIONS(254), 1, + anon_sym_CARET, + STATE(86), 1, + sym_comment, + ACTIONS(240), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(242), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(248), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(150), 15, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + ACTIONS(152), 19, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + sym_identifier, + [6023] = 11, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(244), 1, + anon_sym_PLUS, + ACTIONS(246), 1, + anon_sym_DASH, + ACTIONS(250), 1, + anon_sym_SLASH, + ACTIONS(252), 1, + anon_sym_DOT_DOT, + ACTIONS(254), 1, + anon_sym_CARET, + STATE(87), 1, + sym_comment, + ACTIONS(248), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(150), 18, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(152), 21, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_identifier, + [6097] = 8, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(250), 1, + anon_sym_SLASH, + ACTIONS(254), 1, + anon_sym_CARET, + STATE(88), 1, + sym_comment, + ACTIONS(248), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(150), 20, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_DOT_DOT, + ACTIONS(152), 22, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + sym_identifier, + [6165] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(254), 1, + anon_sym_CARET, + STATE(89), 1, + sym_comment, + ACTIONS(152), 23, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + sym_identifier, + ACTIONS(150), 24, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [6229] = 11, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(244), 1, + anon_sym_PLUS, + ACTIONS(246), 1, + anon_sym_DASH, + ACTIONS(250), 1, + anon_sym_SLASH, + ACTIONS(252), 1, + anon_sym_DOT_DOT, + ACTIONS(254), 1, + anon_sym_CARET, + STATE(90), 1, + sym_comment, + ACTIONS(248), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(150), 18, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(152), 21, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_identifier, + [6303] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(254), 1, + anon_sym_CARET, + STATE(91), 1, + sym_comment, + ACTIONS(152), 23, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + sym_identifier, + ACTIONS(150), 24, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [6367] = 21, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(226), 1, + anon_sym_or, + ACTIONS(228), 1, + anon_sym_and, + ACTIONS(232), 1, + anon_sym_PIPE, + ACTIONS(234), 1, + anon_sym_TILDE, + ACTIONS(236), 1, + anon_sym_CARET_CARET, + ACTIONS(238), 1, + anon_sym_AMP, + ACTIONS(244), 1, + anon_sym_PLUS, + ACTIONS(246), 1, + anon_sym_DASH, + ACTIONS(250), 1, + anon_sym_SLASH, + ACTIONS(252), 1, + anon_sym_DOT_DOT, + ACTIONS(254), 1, + anon_sym_CARET, + STATE(92), 1, + sym_comment, + ACTIONS(224), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(240), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(242), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(248), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(230), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + ACTIONS(262), 7, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(264), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [6461] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(93), 1, + sym_comment, + ACTIONS(192), 24, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + ACTIONS(194), 24, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + [6523] = 21, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(226), 1, + anon_sym_or, + ACTIONS(228), 1, + anon_sym_and, + ACTIONS(232), 1, + anon_sym_PIPE, + ACTIONS(234), 1, + anon_sym_TILDE, + ACTIONS(236), 1, + anon_sym_CARET_CARET, + ACTIONS(238), 1, + anon_sym_AMP, + ACTIONS(244), 1, + anon_sym_PLUS, + ACTIONS(246), 1, + anon_sym_DASH, + ACTIONS(250), 1, + anon_sym_SLASH, + ACTIONS(252), 1, + anon_sym_DOT_DOT, + ACTIONS(254), 1, + anon_sym_CARET, + STATE(94), 1, + sym_comment, + ACTIONS(224), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(240), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(242), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(248), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(230), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + ACTIONS(258), 7, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(260), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [6617] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(95), 1, + sym_comment, + ACTIONS(138), 24, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + ACTIONS(140), 24, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + [6679] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(96), 1, + sym_comment, + ACTIONS(138), 24, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + ACTIONS(140), 24, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + [6741] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(97), 1, + sym_comment, + ACTIONS(122), 24, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + ACTIONS(124), 24, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + [6803] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(98), 1, + sym_comment, + ACTIONS(142), 24, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + ACTIONS(144), 24, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + [6865] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(99), 1, + sym_comment, + ACTIONS(126), 24, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + ACTIONS(128), 24, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + [6927] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(100), 1, + sym_comment, + ACTIONS(130), 24, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + ACTIONS(132), 24, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + [6989] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(101), 1, + sym_comment, + ACTIONS(134), 24, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + ACTIONS(136), 24, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + [7051] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(102), 1, + sym_comment, + ACTIONS(110), 24, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + ACTIONS(112), 24, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + anon_sym_LT, + anon_sym_GT, + anon_sym_or, + anon_sym_and, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + sym_identifier, + [7113] = 21, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(226), 1, + anon_sym_or, + ACTIONS(228), 1, + anon_sym_and, + ACTIONS(232), 1, + anon_sym_PIPE, + ACTIONS(234), 1, + anon_sym_TILDE, + ACTIONS(236), 1, + anon_sym_CARET_CARET, + ACTIONS(238), 1, + anon_sym_AMP, + ACTIONS(244), 1, + anon_sym_PLUS, + ACTIONS(246), 1, + anon_sym_DASH, + ACTIONS(250), 1, + anon_sym_SLASH, + ACTIONS(252), 1, + anon_sym_DOT_DOT, + ACTIONS(254), 1, + anon_sym_CARET, + STATE(103), 1, + sym_comment, + ACTIONS(224), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(240), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(242), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(248), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(230), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + ACTIONS(274), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(276), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [7206] = 36, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(13), 1, + anon_sym_return, + ACTIONS(15), 1, + anon_sym_SEMI, + ACTIONS(17), 1, + anon_sym_COLON_COLON, + ACTIONS(19), 1, + sym_break_statement, + ACTIONS(21), 1, + anon_sym_goto, + ACTIONS(23), 1, + anon_sym_do, + ACTIONS(25), 1, + anon_sym_while, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(29), 1, + anon_sym_repeat, + ACTIONS(31), 1, + anon_sym_if, + ACTIONS(33), 1, + anon_sym_for, + ACTIONS(35), 1, + anon_sym_function, + ACTIONS(37), 1, + anon_sym_local, + ACTIONS(39), 1, + anon_sym_QMARK, + ACTIONS(41), 1, + aux_sym_include_statement_token1, + ACTIONS(282), 1, + anon_sym_end, + STATE(104), 1, + sym_comment, + STATE(111), 1, + aux_sym_chunk_repeat1, + STATE(227), 1, + sym_function_call, + STATE(229), 1, + sym_variable, + STATE(286), 1, + sym_statement, + STATE(292), 1, + sym_declaration, + STATE(293), 1, + sym_function_declaration, + STATE(294), 1, + sym__local_function_declaration, + STATE(295), 1, + sym_variable_declaration, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + STATE(342), 1, + sym_parenthesized_expression, + STATE(381), 1, + sym_return_statement, + STATE(471), 1, + sym__variable_assignment_varlist, + STATE(477), 1, + sym__block, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + STATE(275), 14, + sym_empty_statement, + sym_assignment_statement, + sym_compound_assignment_statement, + sym_label_statement, + sym_goto_statement, + sym_do_statement, + sym_while_statement, + sym_shorthand_while_statement, + sym_repeat_statement, + sym_if_statement, + sym_shorthand_if_statement, + sym_for_statement, + sym_print_shorthand_statement, + sym_include_statement, + [7329] = 36, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(13), 1, + anon_sym_return, + ACTIONS(15), 1, + anon_sym_SEMI, + ACTIONS(17), 1, + anon_sym_COLON_COLON, + ACTIONS(19), 1, + sym_break_statement, + ACTIONS(21), 1, + anon_sym_goto, + ACTIONS(23), 1, + anon_sym_do, + ACTIONS(25), 1, + anon_sym_while, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(29), 1, + anon_sym_repeat, + ACTIONS(31), 1, + anon_sym_if, + ACTIONS(33), 1, + anon_sym_for, + ACTIONS(35), 1, + anon_sym_function, + ACTIONS(37), 1, + anon_sym_local, + ACTIONS(39), 1, + anon_sym_QMARK, + ACTIONS(41), 1, + aux_sym_include_statement_token1, + ACTIONS(284), 1, + anon_sym_end, + STATE(105), 1, + sym_comment, + STATE(111), 1, + aux_sym_chunk_repeat1, + STATE(227), 1, + sym_function_call, + STATE(229), 1, + sym_variable, + STATE(286), 1, + sym_statement, + STATE(292), 1, + sym_declaration, + STATE(293), 1, + sym_function_declaration, + STATE(294), 1, + sym__local_function_declaration, + STATE(295), 1, + sym_variable_declaration, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + STATE(342), 1, + sym_parenthesized_expression, + STATE(381), 1, + sym_return_statement, + STATE(439), 1, + sym__block, + STATE(471), 1, + sym__variable_assignment_varlist, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + STATE(275), 14, + sym_empty_statement, + sym_assignment_statement, + sym_compound_assignment_statement, + sym_label_statement, + sym_goto_statement, + sym_do_statement, + sym_while_statement, + sym_shorthand_while_statement, + sym_repeat_statement, + sym_if_statement, + sym_shorthand_if_statement, + sym_for_statement, + sym_print_shorthand_statement, + sym_include_statement, + [7452] = 21, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(226), 1, + anon_sym_or, + ACTIONS(228), 1, + anon_sym_and, + ACTIONS(232), 1, + anon_sym_PIPE, + ACTIONS(234), 1, + anon_sym_TILDE, + ACTIONS(236), 1, + anon_sym_CARET_CARET, + ACTIONS(238), 1, + anon_sym_AMP, + ACTIONS(244), 1, + anon_sym_PLUS, + ACTIONS(246), 1, + anon_sym_DASH, + ACTIONS(250), 1, + anon_sym_SLASH, + ACTIONS(252), 1, + anon_sym_DOT_DOT, + ACTIONS(254), 1, + anon_sym_CARET, + STATE(106), 1, + sym_comment, + ACTIONS(224), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(240), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(242), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(248), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(230), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + ACTIONS(278), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(280), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [7545] = 36, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(13), 1, + anon_sym_return, + ACTIONS(15), 1, + anon_sym_SEMI, + ACTIONS(17), 1, + anon_sym_COLON_COLON, + ACTIONS(19), 1, + sym_break_statement, + ACTIONS(21), 1, + anon_sym_goto, + ACTIONS(23), 1, + anon_sym_do, + ACTIONS(25), 1, + anon_sym_while, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(29), 1, + anon_sym_repeat, + ACTIONS(31), 1, + anon_sym_if, + ACTIONS(33), 1, + anon_sym_for, + ACTIONS(35), 1, + anon_sym_function, + ACTIONS(37), 1, + anon_sym_local, + ACTIONS(39), 1, + anon_sym_QMARK, + ACTIONS(41), 1, + aux_sym_include_statement_token1, + ACTIONS(286), 1, + anon_sym_end, + STATE(107), 1, + sym_comment, + STATE(111), 1, + aux_sym_chunk_repeat1, + STATE(227), 1, + sym_function_call, + STATE(229), 1, + sym_variable, + STATE(286), 1, + sym_statement, + STATE(292), 1, + sym_declaration, + STATE(293), 1, + sym_function_declaration, + STATE(294), 1, + sym__local_function_declaration, + STATE(295), 1, + sym_variable_declaration, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + STATE(342), 1, + sym_parenthesized_expression, + STATE(381), 1, + sym_return_statement, + STATE(461), 1, + sym__block, + STATE(471), 1, + sym__variable_assignment_varlist, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + STATE(275), 14, + sym_empty_statement, + sym_assignment_statement, + sym_compound_assignment_statement, + sym_label_statement, + sym_goto_statement, + sym_do_statement, + sym_while_statement, + sym_shorthand_while_statement, + sym_repeat_statement, + sym_if_statement, + sym_shorthand_if_statement, + sym_for_statement, + sym_print_shorthand_statement, + sym_include_statement, + [7668] = 21, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(226), 1, + anon_sym_or, + ACTIONS(228), 1, + anon_sym_and, + ACTIONS(232), 1, + anon_sym_PIPE, + ACTIONS(234), 1, + anon_sym_TILDE, + ACTIONS(236), 1, + anon_sym_CARET_CARET, + ACTIONS(238), 1, + anon_sym_AMP, + ACTIONS(244), 1, + anon_sym_PLUS, + ACTIONS(246), 1, + anon_sym_DASH, + ACTIONS(250), 1, + anon_sym_SLASH, + ACTIONS(252), 1, + anon_sym_DOT_DOT, + ACTIONS(254), 1, + anon_sym_CARET, + STATE(108), 1, + sym_comment, + ACTIONS(224), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(240), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(242), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(248), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(230), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + ACTIONS(270), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(272), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [7761] = 36, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(13), 1, + anon_sym_return, + ACTIONS(15), 1, + anon_sym_SEMI, + ACTIONS(17), 1, + anon_sym_COLON_COLON, + ACTIONS(19), 1, + sym_break_statement, + ACTIONS(21), 1, + anon_sym_goto, + ACTIONS(23), 1, + anon_sym_do, + ACTIONS(25), 1, + anon_sym_while, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(29), 1, + anon_sym_repeat, + ACTIONS(31), 1, + anon_sym_if, + ACTIONS(33), 1, + anon_sym_for, + ACTIONS(35), 1, + anon_sym_function, + ACTIONS(37), 1, + anon_sym_local, + ACTIONS(39), 1, + anon_sym_QMARK, + ACTIONS(41), 1, + aux_sym_include_statement_token1, + ACTIONS(288), 1, + anon_sym_end, + STATE(109), 1, + sym_comment, + STATE(111), 1, + aux_sym_chunk_repeat1, + STATE(227), 1, + sym_function_call, + STATE(229), 1, + sym_variable, + STATE(286), 1, + sym_statement, + STATE(292), 1, + sym_declaration, + STATE(293), 1, + sym_function_declaration, + STATE(294), 1, + sym__local_function_declaration, + STATE(295), 1, + sym_variable_declaration, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + STATE(342), 1, + sym_parenthesized_expression, + STATE(381), 1, + sym_return_statement, + STATE(425), 1, + sym__block, + STATE(471), 1, + sym__variable_assignment_varlist, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + STATE(275), 14, + sym_empty_statement, + sym_assignment_statement, + sym_compound_assignment_statement, + sym_label_statement, + sym_goto_statement, + sym_do_statement, + sym_while_statement, + sym_shorthand_while_statement, + sym_repeat_statement, + sym_if_statement, + sym_shorthand_if_statement, + sym_for_statement, + sym_print_shorthand_statement, + sym_include_statement, + [7884] = 33, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(290), 1, + ts_builtin_sym_end, + ACTIONS(292), 1, + sym_identifier, + ACTIONS(297), 1, + anon_sym_SEMI, + ACTIONS(300), 1, + anon_sym_COLON_COLON, + ACTIONS(303), 1, + sym_break_statement, + ACTIONS(306), 1, + anon_sym_goto, + ACTIONS(309), 1, + anon_sym_do, + ACTIONS(312), 1, + anon_sym_while, + ACTIONS(315), 1, + anon_sym_LPAREN, + ACTIONS(318), 1, + anon_sym_repeat, + ACTIONS(321), 1, + anon_sym_if, + ACTIONS(324), 1, + anon_sym_for, + ACTIONS(327), 1, + anon_sym_function, + ACTIONS(330), 1, + anon_sym_local, + ACTIONS(333), 1, + anon_sym_QMARK, + ACTIONS(336), 1, + aux_sym_include_statement_token1, + STATE(227), 1, + sym_function_call, + STATE(229), 1, + sym_variable, + STATE(286), 1, + sym_statement, + STATE(292), 1, + sym_declaration, + STATE(293), 1, + sym_function_declaration, + STATE(294), 1, + sym__local_function_declaration, + STATE(295), 1, + sym_variable_declaration, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + STATE(342), 1, + sym_parenthesized_expression, + STATE(471), 1, + sym__variable_assignment_varlist, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + STATE(110), 2, + sym_comment, + aux_sym_chunk_repeat1, + ACTIONS(295), 3, + anon_sym_return, + anon_sym_end, + anon_sym_until, + STATE(275), 14, + sym_empty_statement, + sym_assignment_statement, + sym_compound_assignment_statement, + sym_label_statement, + sym_goto_statement, + sym_do_statement, + sym_while_statement, + sym_shorthand_while_statement, + sym_repeat_statement, + sym_if_statement, + sym_shorthand_if_statement, + sym_for_statement, + sym_print_shorthand_statement, + sym_include_statement, + [8001] = 35, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(13), 1, + anon_sym_return, + ACTIONS(15), 1, + anon_sym_SEMI, + ACTIONS(17), 1, + anon_sym_COLON_COLON, + ACTIONS(19), 1, + sym_break_statement, + ACTIONS(21), 1, + anon_sym_goto, + ACTIONS(23), 1, + anon_sym_do, + ACTIONS(25), 1, + anon_sym_while, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(29), 1, + anon_sym_repeat, + ACTIONS(31), 1, + anon_sym_if, + ACTIONS(33), 1, + anon_sym_for, + ACTIONS(35), 1, + anon_sym_function, + ACTIONS(37), 1, + anon_sym_local, + ACTIONS(39), 1, + anon_sym_QMARK, + ACTIONS(41), 1, + aux_sym_include_statement_token1, + STATE(110), 1, + aux_sym_chunk_repeat1, + STATE(111), 1, + sym_comment, + STATE(227), 1, + sym_function_call, + STATE(229), 1, + sym_variable, + STATE(286), 1, + sym_statement, + STATE(292), 1, + sym_declaration, + STATE(293), 1, + sym_function_declaration, + STATE(294), 1, + sym__local_function_declaration, + STATE(295), 1, + sym_variable_declaration, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + STATE(342), 1, + sym_parenthesized_expression, + STATE(382), 1, + sym_return_statement, + STATE(471), 1, + sym__variable_assignment_varlist, + ACTIONS(268), 2, + anon_sym_end, + anon_sym_until, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + STATE(275), 14, + sym_empty_statement, + sym_assignment_statement, + sym_compound_assignment_statement, + sym_label_statement, + sym_goto_statement, + sym_do_statement, + sym_while_statement, + sym_shorthand_while_statement, + sym_repeat_statement, + sym_if_statement, + sym_shorthand_if_statement, + sym_for_statement, + sym_print_shorthand_statement, + sym_include_statement, + [8122] = 36, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(13), 1, + anon_sym_return, + ACTIONS(15), 1, + anon_sym_SEMI, + ACTIONS(17), 1, + anon_sym_COLON_COLON, + ACTIONS(19), 1, + sym_break_statement, + ACTIONS(21), 1, + anon_sym_goto, + ACTIONS(23), 1, + anon_sym_do, + ACTIONS(25), 1, + anon_sym_while, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(29), 1, + anon_sym_repeat, + ACTIONS(31), 1, + anon_sym_if, + ACTIONS(33), 1, + anon_sym_for, + ACTIONS(35), 1, + anon_sym_function, + ACTIONS(37), 1, + anon_sym_local, + ACTIONS(39), 1, + anon_sym_QMARK, + ACTIONS(41), 1, + aux_sym_include_statement_token1, + ACTIONS(339), 1, + anon_sym_end, + STATE(111), 1, + aux_sym_chunk_repeat1, + STATE(112), 1, + sym_comment, + STATE(227), 1, + sym_function_call, + STATE(229), 1, + sym_variable, + STATE(286), 1, + sym_statement, + STATE(292), 1, + sym_declaration, + STATE(293), 1, + sym_function_declaration, + STATE(294), 1, + sym__local_function_declaration, + STATE(295), 1, + sym_variable_declaration, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + STATE(342), 1, + sym_parenthesized_expression, + STATE(381), 1, + sym_return_statement, + STATE(471), 1, + sym__variable_assignment_varlist, + STATE(485), 1, + sym__block, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + STATE(275), 14, + sym_empty_statement, + sym_assignment_statement, + sym_compound_assignment_statement, + sym_label_statement, + sym_goto_statement, + sym_do_statement, + sym_while_statement, + sym_shorthand_while_statement, + sym_repeat_statement, + sym_if_statement, + sym_shorthand_if_statement, + sym_for_statement, + sym_print_shorthand_statement, + sym_include_statement, + [8245] = 36, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(13), 1, + anon_sym_return, + ACTIONS(15), 1, + anon_sym_SEMI, + ACTIONS(17), 1, + anon_sym_COLON_COLON, + ACTIONS(19), 1, + sym_break_statement, + ACTIONS(21), 1, + anon_sym_goto, + ACTIONS(23), 1, + anon_sym_do, + ACTIONS(25), 1, + anon_sym_while, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(29), 1, + anon_sym_repeat, + ACTIONS(31), 1, + anon_sym_if, + ACTIONS(33), 1, + anon_sym_for, + ACTIONS(35), 1, + anon_sym_function, + ACTIONS(37), 1, + anon_sym_local, + ACTIONS(39), 1, + anon_sym_QMARK, + ACTIONS(41), 1, + aux_sym_include_statement_token1, + ACTIONS(341), 1, + anon_sym_end, + STATE(111), 1, + aux_sym_chunk_repeat1, + STATE(113), 1, + sym_comment, + STATE(227), 1, + sym_function_call, + STATE(229), 1, + sym_variable, + STATE(286), 1, + sym_statement, + STATE(292), 1, + sym_declaration, + STATE(293), 1, + sym_function_declaration, + STATE(294), 1, + sym__local_function_declaration, + STATE(295), 1, + sym_variable_declaration, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + STATE(342), 1, + sym_parenthesized_expression, + STATE(381), 1, + sym_return_statement, + STATE(471), 1, + sym__variable_assignment_varlist, + STATE(480), 1, + sym__block, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + STATE(275), 14, + sym_empty_statement, + sym_assignment_statement, + sym_compound_assignment_statement, + sym_label_statement, + sym_goto_statement, + sym_do_statement, + sym_while_statement, + sym_shorthand_while_statement, + sym_repeat_statement, + sym_if_statement, + sym_shorthand_if_statement, + sym_for_statement, + sym_print_shorthand_statement, + sym_include_statement, + [8368] = 36, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(13), 1, + anon_sym_return, + ACTIONS(15), 1, + anon_sym_SEMI, + ACTIONS(17), 1, + anon_sym_COLON_COLON, + ACTIONS(19), 1, + sym_break_statement, + ACTIONS(21), 1, + anon_sym_goto, + ACTIONS(23), 1, + anon_sym_do, + ACTIONS(25), 1, + anon_sym_while, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(29), 1, + anon_sym_repeat, + ACTIONS(31), 1, + anon_sym_if, + ACTIONS(33), 1, + anon_sym_for, + ACTIONS(35), 1, + anon_sym_function, + ACTIONS(37), 1, + anon_sym_local, + ACTIONS(39), 1, + anon_sym_QMARK, + ACTIONS(41), 1, + aux_sym_include_statement_token1, + ACTIONS(343), 1, + anon_sym_until, + STATE(111), 1, + aux_sym_chunk_repeat1, + STATE(114), 1, + sym_comment, + STATE(227), 1, + sym_function_call, + STATE(229), 1, + sym_variable, + STATE(286), 1, + sym_statement, + STATE(292), 1, + sym_declaration, + STATE(293), 1, + sym_function_declaration, + STATE(294), 1, + sym__local_function_declaration, + STATE(295), 1, + sym_variable_declaration, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + STATE(342), 1, + sym_parenthesized_expression, + STATE(381), 1, + sym_return_statement, + STATE(414), 1, + sym__block, + STATE(471), 1, + sym__variable_assignment_varlist, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + STATE(275), 14, + sym_empty_statement, + sym_assignment_statement, + sym_compound_assignment_statement, + sym_label_statement, + sym_goto_statement, + sym_do_statement, + sym_while_statement, + sym_shorthand_while_statement, + sym_repeat_statement, + sym_if_statement, + sym_shorthand_if_statement, + sym_for_statement, + sym_print_shorthand_statement, + sym_include_statement, + [8491] = 36, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(13), 1, + anon_sym_return, + ACTIONS(15), 1, + anon_sym_SEMI, + ACTIONS(17), 1, + anon_sym_COLON_COLON, + ACTIONS(19), 1, + sym_break_statement, + ACTIONS(21), 1, + anon_sym_goto, + ACTIONS(23), 1, + anon_sym_do, + ACTIONS(25), 1, + anon_sym_while, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(29), 1, + anon_sym_repeat, + ACTIONS(31), 1, + anon_sym_if, + ACTIONS(33), 1, + anon_sym_for, + ACTIONS(35), 1, + anon_sym_function, + ACTIONS(37), 1, + anon_sym_local, + ACTIONS(39), 1, + anon_sym_QMARK, + ACTIONS(41), 1, + aux_sym_include_statement_token1, + ACTIONS(345), 1, + anon_sym_end, + STATE(111), 1, + aux_sym_chunk_repeat1, + STATE(115), 1, + sym_comment, + STATE(227), 1, + sym_function_call, + STATE(229), 1, + sym_variable, + STATE(286), 1, + sym_statement, + STATE(292), 1, + sym_declaration, + STATE(293), 1, + sym_function_declaration, + STATE(294), 1, + sym__local_function_declaration, + STATE(295), 1, + sym_variable_declaration, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + STATE(342), 1, + sym_parenthesized_expression, + STATE(381), 1, + sym_return_statement, + STATE(433), 1, + sym__block, + STATE(471), 1, + sym__variable_assignment_varlist, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + STATE(275), 14, + sym_empty_statement, + sym_assignment_statement, + sym_compound_assignment_statement, + sym_label_statement, + sym_goto_statement, + sym_do_statement, + sym_while_statement, + sym_shorthand_while_statement, + sym_repeat_statement, + sym_if_statement, + sym_shorthand_if_statement, + sym_for_statement, + sym_print_shorthand_statement, + sym_include_statement, + [8614] = 36, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(13), 1, + anon_sym_return, + ACTIONS(15), 1, + anon_sym_SEMI, + ACTIONS(17), 1, + anon_sym_COLON_COLON, + ACTIONS(19), 1, + sym_break_statement, + ACTIONS(21), 1, + anon_sym_goto, + ACTIONS(23), 1, + anon_sym_do, + ACTIONS(25), 1, + anon_sym_while, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(29), 1, + anon_sym_repeat, + ACTIONS(31), 1, + anon_sym_if, + ACTIONS(33), 1, + anon_sym_for, + ACTIONS(35), 1, + anon_sym_function, + ACTIONS(37), 1, + anon_sym_local, + ACTIONS(39), 1, + anon_sym_QMARK, + ACTIONS(41), 1, + aux_sym_include_statement_token1, + ACTIONS(347), 1, + anon_sym_end, + STATE(111), 1, + aux_sym_chunk_repeat1, + STATE(116), 1, + sym_comment, + STATE(227), 1, + sym_function_call, + STATE(229), 1, + sym_variable, + STATE(286), 1, + sym_statement, + STATE(292), 1, + sym_declaration, + STATE(293), 1, + sym_function_declaration, + STATE(294), 1, + sym__local_function_declaration, + STATE(295), 1, + sym_variable_declaration, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + STATE(342), 1, + sym_parenthesized_expression, + STATE(381), 1, + sym_return_statement, + STATE(434), 1, + sym__block, + STATE(471), 1, + sym__variable_assignment_varlist, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + STATE(275), 14, + sym_empty_statement, + sym_assignment_statement, + sym_compound_assignment_statement, + sym_label_statement, + sym_goto_statement, + sym_do_statement, + sym_while_statement, + sym_shorthand_while_statement, + sym_repeat_statement, + sym_if_statement, + sym_shorthand_if_statement, + sym_for_statement, + sym_print_shorthand_statement, + sym_include_statement, + [8737] = 36, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(13), 1, + anon_sym_return, + ACTIONS(15), 1, + anon_sym_SEMI, + ACTIONS(17), 1, + anon_sym_COLON_COLON, + ACTIONS(19), 1, + sym_break_statement, + ACTIONS(21), 1, + anon_sym_goto, + ACTIONS(23), 1, + anon_sym_do, + ACTIONS(25), 1, + anon_sym_while, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(29), 1, + anon_sym_repeat, + ACTIONS(31), 1, + anon_sym_if, + ACTIONS(33), 1, + anon_sym_for, + ACTIONS(35), 1, + anon_sym_function, + ACTIONS(37), 1, + anon_sym_local, + ACTIONS(39), 1, + anon_sym_QMARK, + ACTIONS(41), 1, + aux_sym_include_statement_token1, + ACTIONS(349), 1, + anon_sym_until, + STATE(111), 1, + aux_sym_chunk_repeat1, + STATE(117), 1, + sym_comment, + STATE(227), 1, + sym_function_call, + STATE(229), 1, + sym_variable, + STATE(286), 1, + sym_statement, + STATE(292), 1, + sym_declaration, + STATE(293), 1, + sym_function_declaration, + STATE(294), 1, + sym__local_function_declaration, + STATE(295), 1, + sym_variable_declaration, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + STATE(342), 1, + sym_parenthesized_expression, + STATE(381), 1, + sym_return_statement, + STATE(471), 1, + sym__variable_assignment_varlist, + STATE(479), 1, + sym__block, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + STATE(275), 14, + sym_empty_statement, + sym_assignment_statement, + sym_compound_assignment_statement, + sym_label_statement, + sym_goto_statement, + sym_do_statement, + sym_while_statement, + sym_shorthand_while_statement, + sym_repeat_statement, + sym_if_statement, + sym_shorthand_if_statement, + sym_for_statement, + sym_print_shorthand_statement, + sym_include_statement, + [8860] = 36, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(13), 1, + anon_sym_return, + ACTIONS(15), 1, + anon_sym_SEMI, + ACTIONS(17), 1, + anon_sym_COLON_COLON, + ACTIONS(19), 1, + sym_break_statement, + ACTIONS(21), 1, + anon_sym_goto, + ACTIONS(23), 1, + anon_sym_do, + ACTIONS(25), 1, + anon_sym_while, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(29), 1, + anon_sym_repeat, + ACTIONS(31), 1, + anon_sym_if, + ACTIONS(33), 1, + anon_sym_for, + ACTIONS(35), 1, + anon_sym_function, + ACTIONS(37), 1, + anon_sym_local, + ACTIONS(39), 1, + anon_sym_QMARK, + ACTIONS(41), 1, + aux_sym_include_statement_token1, + ACTIONS(351), 1, + anon_sym_end, + STATE(111), 1, + aux_sym_chunk_repeat1, + STATE(118), 1, + sym_comment, + STATE(227), 1, + sym_function_call, + STATE(229), 1, + sym_variable, + STATE(286), 1, + sym_statement, + STATE(292), 1, + sym_declaration, + STATE(293), 1, + sym_function_declaration, + STATE(294), 1, + sym__local_function_declaration, + STATE(295), 1, + sym_variable_declaration, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + STATE(342), 1, + sym_parenthesized_expression, + STATE(381), 1, + sym_return_statement, + STATE(438), 1, + sym__block, + STATE(471), 1, + sym__variable_assignment_varlist, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + STATE(275), 14, + sym_empty_statement, + sym_assignment_statement, + sym_compound_assignment_statement, + sym_label_statement, + sym_goto_statement, + sym_do_statement, + sym_while_statement, + sym_shorthand_while_statement, + sym_repeat_statement, + sym_if_statement, + sym_shorthand_if_statement, + sym_for_statement, + sym_print_shorthand_statement, + sym_include_statement, + [8983] = 32, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(292), 1, + sym_identifier, + ACTIONS(297), 1, + anon_sym_SEMI, + ACTIONS(300), 1, + anon_sym_COLON_COLON, + ACTIONS(303), 1, + sym_break_statement, + ACTIONS(306), 1, + anon_sym_goto, + ACTIONS(309), 1, + anon_sym_do, + ACTIONS(315), 1, + anon_sym_LPAREN, + ACTIONS(318), 1, + anon_sym_repeat, + ACTIONS(324), 1, + anon_sym_for, + ACTIONS(327), 1, + anon_sym_function, + ACTIONS(330), 1, + anon_sym_local, + ACTIONS(333), 1, + anon_sym_QMARK, + ACTIONS(336), 1, + aux_sym_include_statement_token1, + ACTIONS(353), 1, + anon_sym_while, + ACTIONS(356), 1, + anon_sym_if, + STATE(227), 1, + sym_function_call, + STATE(229), 1, + sym_variable, + STATE(286), 1, + sym_statement, + STATE(292), 1, + sym_declaration, + STATE(293), 1, + sym_function_declaration, + STATE(294), 1, + sym__local_function_declaration, + STATE(295), 1, + sym_variable_declaration, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + STATE(342), 1, + sym_parenthesized_expression, + STATE(471), 1, + sym__variable_assignment_varlist, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + STATE(119), 2, + sym_comment, + aux_sym_chunk_repeat1, + ACTIONS(295), 4, + anon_sym_return, + anon_sym_end, + anon_sym_elseif, + anon_sym_else, + STATE(275), 14, + sym_empty_statement, + sym_assignment_statement, + sym_compound_assignment_statement, + sym_label_statement, + sym_goto_statement, + sym_do_statement, + sym_while_statement, + sym_shorthand_while_statement, + sym_repeat_statement, + sym_if_statement, + sym_shorthand_if_statement, + sym_for_statement, + sym_print_shorthand_statement, + sym_include_statement, + [9098] = 35, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(13), 1, + anon_sym_return, + ACTIONS(15), 1, + anon_sym_SEMI, + ACTIONS(17), 1, + anon_sym_COLON_COLON, + ACTIONS(19), 1, + sym_break_statement, + ACTIONS(21), 1, + anon_sym_goto, + ACTIONS(23), 1, + anon_sym_do, + ACTIONS(25), 1, + anon_sym_while, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(29), 1, + anon_sym_repeat, + ACTIONS(31), 1, + anon_sym_if, + ACTIONS(33), 1, + anon_sym_for, + ACTIONS(35), 1, + anon_sym_function, + ACTIONS(37), 1, + anon_sym_local, + ACTIONS(39), 1, + anon_sym_QMARK, + ACTIONS(41), 1, + aux_sym_include_statement_token1, + ACTIONS(359), 1, + ts_builtin_sym_end, + STATE(110), 1, + aux_sym_chunk_repeat1, + STATE(120), 1, + sym_comment, + STATE(227), 1, + sym_function_call, + STATE(229), 1, + sym_variable, + STATE(286), 1, + sym_statement, + STATE(292), 1, + sym_declaration, + STATE(293), 1, + sym_function_declaration, + STATE(294), 1, + sym__local_function_declaration, + STATE(295), 1, + sym_variable_declaration, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + STATE(342), 1, + sym_parenthesized_expression, + STATE(426), 1, + sym_return_statement, + STATE(471), 1, + sym__variable_assignment_varlist, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + STATE(275), 14, + sym_empty_statement, + sym_assignment_statement, + sym_compound_assignment_statement, + sym_label_statement, + sym_goto_statement, + sym_do_statement, + sym_while_statement, + sym_shorthand_while_statement, + sym_repeat_statement, + sym_if_statement, + sym_shorthand_if_statement, + sym_for_statement, + sym_print_shorthand_statement, + sym_include_statement, + [9218] = 35, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(13), 1, + anon_sym_return, + ACTIONS(15), 1, + anon_sym_SEMI, + ACTIONS(17), 1, + anon_sym_COLON_COLON, + ACTIONS(19), 1, + sym_break_statement, + ACTIONS(21), 1, + anon_sym_goto, + ACTIONS(23), 1, + anon_sym_do, + ACTIONS(25), 1, + anon_sym_while, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(29), 1, + anon_sym_repeat, + ACTIONS(31), 1, + anon_sym_if, + ACTIONS(33), 1, + anon_sym_for, + ACTIONS(35), 1, + anon_sym_function, + ACTIONS(37), 1, + anon_sym_local, + ACTIONS(39), 1, + anon_sym_QMARK, + ACTIONS(41), 1, + aux_sym_include_statement_token1, + ACTIONS(361), 1, + ts_builtin_sym_end, + STATE(110), 1, + aux_sym_chunk_repeat1, + STATE(121), 1, + sym_comment, + STATE(227), 1, + sym_function_call, + STATE(229), 1, + sym_variable, + STATE(286), 1, + sym_statement, + STATE(292), 1, + sym_declaration, + STATE(293), 1, + sym_function_declaration, + STATE(294), 1, + sym__local_function_declaration, + STATE(295), 1, + sym_variable_declaration, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + STATE(342), 1, + sym_parenthesized_expression, + STATE(463), 1, + sym_return_statement, + STATE(471), 1, + sym__variable_assignment_varlist, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + STATE(275), 14, + sym_empty_statement, + sym_assignment_statement, + sym_compound_assignment_statement, + sym_label_statement, + sym_goto_statement, + sym_do_statement, + sym_while_statement, + sym_shorthand_while_statement, + sym_repeat_statement, + sym_if_statement, + sym_shorthand_if_statement, + sym_for_statement, + sym_print_shorthand_statement, + sym_include_statement, + [9338] = 35, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(13), 1, + anon_sym_return, + ACTIONS(15), 1, + anon_sym_SEMI, + ACTIONS(17), 1, + anon_sym_COLON_COLON, + ACTIONS(19), 1, + sym_break_statement, + ACTIONS(21), 1, + anon_sym_goto, + ACTIONS(23), 1, + anon_sym_do, + ACTIONS(25), 1, + anon_sym_while, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(29), 1, + anon_sym_repeat, + ACTIONS(31), 1, + anon_sym_if, + ACTIONS(33), 1, + anon_sym_for, + ACTIONS(35), 1, + anon_sym_function, + ACTIONS(37), 1, + anon_sym_local, + ACTIONS(39), 1, + anon_sym_QMARK, + ACTIONS(41), 1, + aux_sym_include_statement_token1, + ACTIONS(359), 1, + ts_builtin_sym_end, + STATE(121), 1, + aux_sym_chunk_repeat1, + STATE(122), 1, + sym_comment, + STATE(227), 1, + sym_function_call, + STATE(229), 1, + sym_variable, + STATE(286), 1, + sym_statement, + STATE(292), 1, + sym_declaration, + STATE(293), 1, + sym_function_declaration, + STATE(294), 1, + sym__local_function_declaration, + STATE(295), 1, + sym_variable_declaration, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + STATE(342), 1, + sym_parenthesized_expression, + STATE(426), 1, + sym_return_statement, + STATE(471), 1, + sym__variable_assignment_varlist, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + STATE(275), 14, + sym_empty_statement, + sym_assignment_statement, + sym_compound_assignment_statement, + sym_label_statement, + sym_goto_statement, + sym_do_statement, + sym_while_statement, + sym_shorthand_while_statement, + sym_repeat_statement, + sym_if_statement, + sym_shorthand_if_statement, + sym_for_statement, + sym_print_shorthand_statement, + sym_include_statement, + [9458] = 31, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(15), 1, + anon_sym_SEMI, + ACTIONS(17), 1, + anon_sym_COLON_COLON, + ACTIONS(19), 1, + sym_break_statement, + ACTIONS(21), 1, + anon_sym_goto, + ACTIONS(23), 1, + anon_sym_do, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(29), 1, + anon_sym_repeat, + ACTIONS(33), 1, + anon_sym_for, + ACTIONS(35), 1, + anon_sym_function, + ACTIONS(37), 1, + anon_sym_local, + ACTIONS(39), 1, + anon_sym_QMARK, + ACTIONS(41), 1, + aux_sym_include_statement_token1, + ACTIONS(88), 1, + anon_sym_while, + ACTIONS(90), 1, + anon_sym_if, + STATE(123), 1, + sym_comment, + STATE(227), 1, + sym_function_call, + STATE(229), 1, + sym_variable, + STATE(266), 1, + sym_statement, + STATE(292), 1, + sym_declaration, + STATE(293), 1, + sym_function_declaration, + STATE(294), 1, + sym__local_function_declaration, + STATE(295), 1, + sym_variable_declaration, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + STATE(342), 1, + sym_parenthesized_expression, + STATE(471), 1, + sym__variable_assignment_varlist, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + STATE(275), 14, + sym_empty_statement, + sym_assignment_statement, + sym_compound_assignment_statement, + sym_label_statement, + sym_goto_statement, + sym_do_statement, + sym_while_statement, + sym_shorthand_while_statement, + sym_repeat_statement, + sym_if_statement, + sym_shorthand_if_statement, + sym_for_statement, + sym_print_shorthand_statement, + sym_include_statement, + [9566] = 31, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(15), 1, + anon_sym_SEMI, + ACTIONS(17), 1, + anon_sym_COLON_COLON, + ACTIONS(19), 1, + sym_break_statement, + ACTIONS(21), 1, + anon_sym_goto, + ACTIONS(23), 1, + anon_sym_do, + ACTIONS(25), 1, + anon_sym_while, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(29), 1, + anon_sym_repeat, + ACTIONS(31), 1, + anon_sym_if, + ACTIONS(33), 1, + anon_sym_for, + ACTIONS(35), 1, + anon_sym_function, + ACTIONS(37), 1, + anon_sym_local, + ACTIONS(39), 1, + anon_sym_QMARK, + ACTIONS(41), 1, + aux_sym_include_statement_token1, + STATE(124), 1, + sym_comment, + STATE(227), 1, + sym_function_call, + STATE(229), 1, + sym_variable, + STATE(266), 1, + sym_statement, + STATE(292), 1, + sym_declaration, + STATE(293), 1, + sym_function_declaration, + STATE(294), 1, + sym__local_function_declaration, + STATE(295), 1, + sym_variable_declaration, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + STATE(342), 1, + sym_parenthesized_expression, + STATE(471), 1, + sym__variable_assignment_varlist, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + STATE(275), 14, + sym_empty_statement, + sym_assignment_statement, + sym_compound_assignment_statement, + sym_label_statement, + sym_goto_statement, + sym_do_statement, + sym_while_statement, + sym_shorthand_while_statement, + sym_repeat_statement, + sym_if_statement, + sym_shorthand_if_statement, + sym_for_statement, + sym_print_shorthand_statement, + sym_include_statement, + [9674] = 31, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(51), 1, + anon_sym_SEMI, + ACTIONS(53), 1, + anon_sym_COLON_COLON, + ACTIONS(55), 1, + sym_break_statement, + ACTIONS(57), 1, + anon_sym_goto, + ACTIONS(59), 1, + anon_sym_do, + ACTIONS(61), 1, + anon_sym_while, + ACTIONS(66), 1, + anon_sym_repeat, + ACTIONS(68), 1, + anon_sym_if, + ACTIONS(72), 1, + anon_sym_for, + ACTIONS(74), 1, + anon_sym_function, + ACTIONS(76), 1, + anon_sym_local, + ACTIONS(78), 1, + anon_sym_QMARK, + ACTIONS(80), 1, + aux_sym_include_statement_token1, + STATE(125), 1, + sym_comment, + STATE(230), 1, + sym_variable, + STATE(231), 1, + sym_function_call, + STATE(311), 1, + sym_declaration, + STATE(315), 1, + sym_statement, + STATE(317), 1, + sym_function_declaration, + STATE(318), 1, + sym__local_function_declaration, + STATE(319), 1, + sym_variable_declaration, + STATE(333), 1, + sym__prefix_expression, + STATE(336), 1, + sym_method_index_expression, + STATE(342), 1, + sym_parenthesized_expression, + STATE(449), 1, + sym__variable_assignment_varlist, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + STATE(304), 14, + sym_empty_statement, + sym_assignment_statement, + sym_compound_assignment_statement, + sym_label_statement, + sym_goto_statement, + sym_do_statement, + sym_while_statement, + sym_shorthand_while_statement, + sym_repeat_statement, + sym_if_statement, + sym_shorthand_if_statement, + sym_for_statement, + sym_print_shorthand_statement, + sym_include_statement, + [9782] = 26, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(363), 1, + ts_builtin_sym_end, + ACTIONS(365), 1, + anon_sym_SEMI, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(126), 1, + sym_comment, + STATE(134), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + STATE(345), 1, + sym__expression_list, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(367), 4, + anon_sym_end, + anon_sym_until, + anon_sym_elseif, + anon_sym_else, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [9879] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(387), 1, + anon_sym_EQ, + STATE(127), 1, + sym_comment, + ACTIONS(45), 9, + anon_sym_DOT, + anon_sym_LT, + anon_sym_GT, + anon_sym_TILDE, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_CARET, + ACTIONS(43), 29, + sym__block_string_start, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_COLON, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_or, + anon_sym_and, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET_CARET, + anon_sym_AMP, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + anon_sym_DOT_DOT, + [9934] = 26, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + ACTIONS(389), 1, + sym_identifier, + ACTIONS(391), 1, + anon_sym_LBRACK, + ACTIONS(393), 1, + anon_sym_RBRACE, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(128), 1, + sym_comment, + STATE(205), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + STATE(353), 1, + sym_field, + STATE(458), 1, + sym__field_list, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [10028] = 26, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + ACTIONS(389), 1, + sym_identifier, + ACTIONS(391), 1, + anon_sym_LBRACK, + ACTIONS(395), 1, + anon_sym_RBRACE, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(129), 1, + sym_comment, + STATE(205), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + STATE(353), 1, + sym_field, + STATE(452), 1, + sym__field_list, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [10122] = 26, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + ACTIONS(389), 1, + sym_identifier, + ACTIONS(391), 1, + anon_sym_LBRACK, + ACTIONS(397), 1, + anon_sym_RBRACE, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(130), 1, + sym_comment, + STATE(205), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + STATE(353), 1, + sym_field, + STATE(451), 1, + sym__field_list, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [10216] = 26, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + ACTIONS(389), 1, + sym_identifier, + ACTIONS(391), 1, + anon_sym_LBRACK, + ACTIONS(399), 1, + anon_sym_RBRACE, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(131), 1, + sym_comment, + STATE(205), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + STATE(353), 1, + sym_field, + STATE(422), 1, + sym__field_list, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [10310] = 25, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + ACTIONS(389), 1, + sym_identifier, + ACTIONS(391), 1, + anon_sym_LBRACK, + ACTIONS(401), 1, + anon_sym_RBRACE, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(132), 1, + sym_comment, + STATE(205), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + STATE(392), 1, + sym_field, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [10401] = 25, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + ACTIONS(389), 1, + sym_identifier, + ACTIONS(391), 1, + anon_sym_LBRACK, + ACTIONS(403), 1, + anon_sym_RBRACE, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(133), 1, + sym_comment, + STATE(205), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + STATE(392), 1, + sym_field, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [10492] = 23, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(407), 1, + anon_sym_COMMA, + ACTIONS(409), 1, + anon_sym_else, + ACTIONS(411), 1, + anon_sym_or, + ACTIONS(413), 1, + anon_sym_and, + STATE(134), 1, + sym_comment, + STATE(341), 1, + aux_sym__expression_list_repeat1, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + ACTIONS(405), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_do, + anon_sym_end, + anon_sym_until, + anon_sym_elseif, + [10578] = 24, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + ACTIONS(389), 1, + sym_identifier, + ACTIONS(391), 1, + anon_sym_LBRACK, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(135), 1, + sym_comment, + STATE(205), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + STATE(392), 1, + sym_field, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [10666] = 21, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(411), 1, + anon_sym_or, + ACTIONS(413), 1, + anon_sym_and, + ACTIONS(417), 1, + anon_sym_else, + STATE(136), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + ACTIONS(415), 8, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_do, + anon_sym_end, + anon_sym_RPAREN, + anon_sym_until, + anon_sym_elseif, + [10748] = 23, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(68), 1, + sym_expression, + STATE(137), 1, + sym_comment, + STATE(270), 1, + sym__variable_assignment_explist, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [10833] = 23, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + ACTIONS(419), 1, + anon_sym_RPAREN, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(138), 1, + sym_comment, + STATE(207), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [10918] = 23, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + ACTIONS(421), 1, + anon_sym_RPAREN, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(139), 1, + sym_comment, + STATE(206), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [11003] = 23, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(423), 1, + sym_identifier, + ACTIONS(425), 1, + anon_sym_LPAREN, + ACTIONS(427), 1, + anon_sym_function, + ACTIONS(433), 1, + anon_sym_DQUOTE, + ACTIONS(435), 1, + anon_sym_SQUOTE, + ACTIONS(437), 1, + anon_sym_LBRACE, + ACTIONS(443), 1, + sym__block_string_start, + STATE(70), 1, + sym_expression, + STATE(95), 1, + sym__quote_string, + STATE(96), 1, + sym__block_string, + STATE(140), 1, + sym_comment, + STATE(303), 1, + sym__variable_assignment_explist, + STATE(334), 1, + sym__prefix_expression, + STATE(336), 1, + sym_method_index_expression, + ACTIONS(431), 2, + sym_number, + sym_vararg_expression, + ACTIONS(441), 2, + anon_sym_DASH, + anon_sym_not, + STATE(27), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(429), 3, + sym_nil, + sym_false, + sym_true, + STATE(28), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(439), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(102), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [11088] = 23, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(134), 1, + sym_expression, + STATE(141), 1, + sym_comment, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + STATE(413), 1, + sym__expression_list, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [11173] = 23, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(68), 1, + sym_expression, + STATE(142), 1, + sym_comment, + STATE(281), 1, + sym__variable_assignment_explist, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [11258] = 23, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(423), 1, + sym_identifier, + ACTIONS(425), 1, + anon_sym_LPAREN, + ACTIONS(427), 1, + anon_sym_function, + ACTIONS(433), 1, + anon_sym_DQUOTE, + ACTIONS(435), 1, + anon_sym_SQUOTE, + ACTIONS(437), 1, + anon_sym_LBRACE, + ACTIONS(443), 1, + sym__block_string_start, + STATE(70), 1, + sym_expression, + STATE(95), 1, + sym__quote_string, + STATE(96), 1, + sym__block_string, + STATE(143), 1, + sym_comment, + STATE(325), 1, + sym__variable_assignment_explist, + STATE(334), 1, + sym__prefix_expression, + STATE(336), 1, + sym_method_index_expression, + ACTIONS(431), 2, + sym_number, + sym_vararg_expression, + ACTIONS(441), 2, + anon_sym_DASH, + anon_sym_not, + STATE(27), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(429), 3, + sym_nil, + sym_false, + sym_true, + STATE(28), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(439), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(102), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [11343] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(423), 1, + sym_identifier, + ACTIONS(425), 1, + anon_sym_LPAREN, + ACTIONS(427), 1, + anon_sym_function, + ACTIONS(433), 1, + anon_sym_DQUOTE, + ACTIONS(435), 1, + anon_sym_SQUOTE, + ACTIONS(437), 1, + anon_sym_LBRACE, + ACTIONS(443), 1, + sym__block_string_start, + STATE(87), 1, + sym_expression, + STATE(95), 1, + sym__quote_string, + STATE(96), 1, + sym__block_string, + STATE(144), 1, + sym_comment, + STATE(334), 1, + sym__prefix_expression, + STATE(336), 1, + sym_method_index_expression, + ACTIONS(431), 2, + sym_number, + sym_vararg_expression, + ACTIONS(441), 2, + anon_sym_DASH, + anon_sym_not, + STATE(27), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(429), 3, + sym_nil, + sym_false, + sym_true, + STATE(28), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(439), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(102), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [11425] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(79), 1, + sym_expression, + STATE(145), 1, + sym_comment, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [11507] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(423), 1, + sym_identifier, + ACTIONS(425), 1, + anon_sym_LPAREN, + ACTIONS(427), 1, + anon_sym_function, + ACTIONS(433), 1, + anon_sym_DQUOTE, + ACTIONS(435), 1, + anon_sym_SQUOTE, + ACTIONS(437), 1, + anon_sym_LBRACE, + ACTIONS(443), 1, + sym__block_string_start, + STATE(95), 1, + sym__quote_string, + STATE(96), 1, + sym__block_string, + STATE(106), 1, + sym_expression, + STATE(146), 1, + sym_comment, + STATE(334), 1, + sym__prefix_expression, + STATE(336), 1, + sym_method_index_expression, + ACTIONS(431), 2, + sym_number, + sym_vararg_expression, + ACTIONS(441), 2, + anon_sym_DASH, + anon_sym_not, + STATE(27), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(429), 3, + sym_nil, + sym_false, + sym_true, + STATE(28), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(439), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(102), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [11589] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + ACTIONS(445), 1, + anon_sym_LPAREN, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(147), 1, + sym_comment, + STATE(228), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [11671] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(67), 1, + sym_expression, + STATE(148), 1, + sym_comment, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [11753] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(149), 1, + sym_comment, + STATE(214), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [11835] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(423), 1, + sym_identifier, + ACTIONS(425), 1, + anon_sym_LPAREN, + ACTIONS(427), 1, + anon_sym_function, + ACTIONS(433), 1, + anon_sym_DQUOTE, + ACTIONS(435), 1, + anon_sym_SQUOTE, + ACTIONS(437), 1, + anon_sym_LBRACE, + ACTIONS(443), 1, + sym__block_string_start, + STATE(81), 1, + sym_expression, + STATE(95), 1, + sym__quote_string, + STATE(96), 1, + sym__block_string, + STATE(150), 1, + sym_comment, + STATE(334), 1, + sym__prefix_expression, + STATE(336), 1, + sym_method_index_expression, + ACTIONS(431), 2, + sym_number, + sym_vararg_expression, + ACTIONS(441), 2, + anon_sym_DASH, + anon_sym_not, + STATE(27), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(429), 3, + sym_nil, + sym_false, + sym_true, + STATE(28), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(439), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(102), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [11917] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(423), 1, + sym_identifier, + ACTIONS(425), 1, + anon_sym_LPAREN, + ACTIONS(427), 1, + anon_sym_function, + ACTIONS(433), 1, + anon_sym_DQUOTE, + ACTIONS(435), 1, + anon_sym_SQUOTE, + ACTIONS(437), 1, + anon_sym_LBRACE, + ACTIONS(443), 1, + sym__block_string_start, + STATE(82), 1, + sym_expression, + STATE(95), 1, + sym__quote_string, + STATE(96), 1, + sym__block_string, + STATE(151), 1, + sym_comment, + STATE(334), 1, + sym__prefix_expression, + STATE(336), 1, + sym_method_index_expression, + ACTIONS(431), 2, + sym_number, + sym_vararg_expression, + ACTIONS(441), 2, + anon_sym_DASH, + anon_sym_not, + STATE(27), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(429), 3, + sym_nil, + sym_false, + sym_true, + STATE(28), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(439), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(102), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [11999] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(423), 1, + sym_identifier, + ACTIONS(425), 1, + anon_sym_LPAREN, + ACTIONS(427), 1, + anon_sym_function, + ACTIONS(433), 1, + anon_sym_DQUOTE, + ACTIONS(435), 1, + anon_sym_SQUOTE, + ACTIONS(437), 1, + anon_sym_LBRACE, + ACTIONS(443), 1, + sym__block_string_start, + STATE(83), 1, + sym_expression, + STATE(95), 1, + sym__quote_string, + STATE(96), 1, + sym__block_string, + STATE(152), 1, + sym_comment, + STATE(334), 1, + sym__prefix_expression, + STATE(336), 1, + sym_method_index_expression, + ACTIONS(431), 2, + sym_number, + sym_vararg_expression, + ACTIONS(441), 2, + anon_sym_DASH, + anon_sym_not, + STATE(27), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(429), 3, + sym_nil, + sym_false, + sym_true, + STATE(28), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(439), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(102), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [12081] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(423), 1, + sym_identifier, + ACTIONS(425), 1, + anon_sym_LPAREN, + ACTIONS(427), 1, + anon_sym_function, + ACTIONS(433), 1, + anon_sym_DQUOTE, + ACTIONS(435), 1, + anon_sym_SQUOTE, + ACTIONS(437), 1, + anon_sym_LBRACE, + ACTIONS(443), 1, + sym__block_string_start, + STATE(84), 1, + sym_expression, + STATE(95), 1, + sym__quote_string, + STATE(96), 1, + sym__block_string, + STATE(153), 1, + sym_comment, + STATE(334), 1, + sym__prefix_expression, + STATE(336), 1, + sym_method_index_expression, + ACTIONS(431), 2, + sym_number, + sym_vararg_expression, + ACTIONS(441), 2, + anon_sym_DASH, + anon_sym_not, + STATE(27), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(429), 3, + sym_nil, + sym_false, + sym_true, + STATE(28), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(439), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(102), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [12163] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(423), 1, + sym_identifier, + ACTIONS(425), 1, + anon_sym_LPAREN, + ACTIONS(427), 1, + anon_sym_function, + ACTIONS(433), 1, + anon_sym_DQUOTE, + ACTIONS(435), 1, + anon_sym_SQUOTE, + ACTIONS(437), 1, + anon_sym_LBRACE, + ACTIONS(443), 1, + sym__block_string_start, + STATE(85), 1, + sym_expression, + STATE(95), 1, + sym__quote_string, + STATE(96), 1, + sym__block_string, + STATE(154), 1, + sym_comment, + STATE(334), 1, + sym__prefix_expression, + STATE(336), 1, + sym_method_index_expression, + ACTIONS(431), 2, + sym_number, + sym_vararg_expression, + ACTIONS(441), 2, + anon_sym_DASH, + anon_sym_not, + STATE(27), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(429), 3, + sym_nil, + sym_false, + sym_true, + STATE(28), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(439), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(102), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [12245] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(423), 1, + sym_identifier, + ACTIONS(425), 1, + anon_sym_LPAREN, + ACTIONS(427), 1, + anon_sym_function, + ACTIONS(433), 1, + anon_sym_DQUOTE, + ACTIONS(435), 1, + anon_sym_SQUOTE, + ACTIONS(437), 1, + anon_sym_LBRACE, + ACTIONS(443), 1, + sym__block_string_start, + STATE(86), 1, + sym_expression, + STATE(95), 1, + sym__quote_string, + STATE(96), 1, + sym__block_string, + STATE(155), 1, + sym_comment, + STATE(334), 1, + sym__prefix_expression, + STATE(336), 1, + sym_method_index_expression, + ACTIONS(431), 2, + sym_number, + sym_vararg_expression, + ACTIONS(441), 2, + anon_sym_DASH, + anon_sym_not, + STATE(27), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(429), 3, + sym_nil, + sym_false, + sym_true, + STATE(28), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(439), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(102), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [12327] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(423), 1, + sym_identifier, + ACTIONS(425), 1, + anon_sym_LPAREN, + ACTIONS(427), 1, + anon_sym_function, + ACTIONS(433), 1, + anon_sym_DQUOTE, + ACTIONS(435), 1, + anon_sym_SQUOTE, + ACTIONS(437), 1, + anon_sym_LBRACE, + ACTIONS(443), 1, + sym__block_string_start, + STATE(88), 1, + sym_expression, + STATE(95), 1, + sym__quote_string, + STATE(96), 1, + sym__block_string, + STATE(156), 1, + sym_comment, + STATE(334), 1, + sym__prefix_expression, + STATE(336), 1, + sym_method_index_expression, + ACTIONS(431), 2, + sym_number, + sym_vararg_expression, + ACTIONS(441), 2, + anon_sym_DASH, + anon_sym_not, + STATE(27), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(429), 3, + sym_nil, + sym_false, + sym_true, + STATE(28), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(439), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(102), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [12409] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(423), 1, + sym_identifier, + ACTIONS(425), 1, + anon_sym_LPAREN, + ACTIONS(427), 1, + anon_sym_function, + ACTIONS(433), 1, + anon_sym_DQUOTE, + ACTIONS(435), 1, + anon_sym_SQUOTE, + ACTIONS(437), 1, + anon_sym_LBRACE, + ACTIONS(443), 1, + sym__block_string_start, + STATE(89), 1, + sym_expression, + STATE(95), 1, + sym__quote_string, + STATE(96), 1, + sym__block_string, + STATE(157), 1, + sym_comment, + STATE(334), 1, + sym__prefix_expression, + STATE(336), 1, + sym_method_index_expression, + ACTIONS(431), 2, + sym_number, + sym_vararg_expression, + ACTIONS(441), 2, + anon_sym_DASH, + anon_sym_not, + STATE(27), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(429), 3, + sym_nil, + sym_false, + sym_true, + STATE(28), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(439), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(102), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [12491] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(423), 1, + sym_identifier, + ACTIONS(425), 1, + anon_sym_LPAREN, + ACTIONS(427), 1, + anon_sym_function, + ACTIONS(433), 1, + anon_sym_DQUOTE, + ACTIONS(435), 1, + anon_sym_SQUOTE, + ACTIONS(437), 1, + anon_sym_LBRACE, + ACTIONS(443), 1, + sym__block_string_start, + STATE(90), 1, + sym_expression, + STATE(95), 1, + sym__quote_string, + STATE(96), 1, + sym__block_string, + STATE(158), 1, + sym_comment, + STATE(334), 1, + sym__prefix_expression, + STATE(336), 1, + sym_method_index_expression, + ACTIONS(431), 2, + sym_number, + sym_vararg_expression, + ACTIONS(441), 2, + anon_sym_DASH, + anon_sym_not, + STATE(27), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(429), 3, + sym_nil, + sym_false, + sym_true, + STATE(28), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(439), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(102), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [12573] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(423), 1, + sym_identifier, + ACTIONS(425), 1, + anon_sym_LPAREN, + ACTIONS(427), 1, + anon_sym_function, + ACTIONS(433), 1, + anon_sym_DQUOTE, + ACTIONS(435), 1, + anon_sym_SQUOTE, + ACTIONS(437), 1, + anon_sym_LBRACE, + ACTIONS(443), 1, + sym__block_string_start, + STATE(91), 1, + sym_expression, + STATE(95), 1, + sym__quote_string, + STATE(96), 1, + sym__block_string, + STATE(159), 1, + sym_comment, + STATE(334), 1, + sym__prefix_expression, + STATE(336), 1, + sym_method_index_expression, + ACTIONS(431), 2, + sym_number, + sym_vararg_expression, + ACTIONS(441), 2, + anon_sym_DASH, + anon_sym_not, + STATE(27), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(429), 3, + sym_nil, + sym_false, + sym_true, + STATE(28), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(439), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(102), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [12655] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(160), 1, + sym_comment, + STATE(208), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [12737] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(161), 1, + sym_comment, + STATE(226), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [12819] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(423), 1, + sym_identifier, + ACTIONS(425), 1, + anon_sym_LPAREN, + ACTIONS(427), 1, + anon_sym_function, + ACTIONS(433), 1, + anon_sym_DQUOTE, + ACTIONS(435), 1, + anon_sym_SQUOTE, + ACTIONS(437), 1, + anon_sym_LBRACE, + ACTIONS(443), 1, + sym__block_string_start, + STATE(95), 1, + sym__quote_string, + STATE(96), 1, + sym__block_string, + STATE(103), 1, + sym_expression, + STATE(162), 1, + sym_comment, + STATE(334), 1, + sym__prefix_expression, + STATE(336), 1, + sym_method_index_expression, + ACTIONS(431), 2, + sym_number, + sym_vararg_expression, + ACTIONS(441), 2, + anon_sym_DASH, + anon_sym_not, + STATE(27), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(429), 3, + sym_nil, + sym_false, + sym_true, + STATE(28), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(439), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(102), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [12901] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(423), 1, + sym_identifier, + ACTIONS(425), 1, + anon_sym_LPAREN, + ACTIONS(427), 1, + anon_sym_function, + ACTIONS(433), 1, + anon_sym_DQUOTE, + ACTIONS(435), 1, + anon_sym_SQUOTE, + ACTIONS(437), 1, + anon_sym_LBRACE, + ACTIONS(443), 1, + sym__block_string_start, + STATE(92), 1, + sym_expression, + STATE(95), 1, + sym__quote_string, + STATE(96), 1, + sym__block_string, + STATE(163), 1, + sym_comment, + STATE(334), 1, + sym__prefix_expression, + STATE(336), 1, + sym_method_index_expression, + ACTIONS(431), 2, + sym_number, + sym_vararg_expression, + ACTIONS(441), 2, + anon_sym_DASH, + anon_sym_not, + STATE(27), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(429), 3, + sym_nil, + sym_false, + sym_true, + STATE(28), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(439), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(102), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [12983] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(75), 1, + sym_expression, + STATE(164), 1, + sym_comment, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [13065] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(165), 1, + sym_comment, + STATE(213), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [13147] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(136), 1, + sym_expression, + STATE(166), 1, + sym_comment, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [13229] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(55), 1, + sym_expression, + STATE(167), 1, + sym_comment, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [13311] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(56), 1, + sym_expression, + STATE(168), 1, + sym_comment, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [13393] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(62), 1, + sym_expression, + STATE(169), 1, + sym_comment, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [13475] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(64), 1, + sym_expression, + STATE(170), 1, + sym_comment, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [13557] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(42), 1, + sym_expression, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(171), 1, + sym_comment, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [13639] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(43), 1, + sym_expression, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(172), 1, + sym_comment, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [13721] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(63), 1, + sym_expression, + STATE(173), 1, + sym_comment, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [13803] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(46), 1, + sym_expression, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(174), 1, + sym_comment, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [13885] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(47), 1, + sym_expression, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(175), 1, + sym_comment, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [13967] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(44), 1, + sym_expression, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(176), 1, + sym_comment, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [14049] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(177), 1, + sym_comment, + STATE(212), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [14131] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(423), 1, + sym_identifier, + ACTIONS(425), 1, + anon_sym_LPAREN, + ACTIONS(427), 1, + anon_sym_function, + ACTIONS(433), 1, + anon_sym_DQUOTE, + ACTIONS(435), 1, + anon_sym_SQUOTE, + ACTIONS(437), 1, + anon_sym_LBRACE, + ACTIONS(443), 1, + sym__block_string_start, + STATE(94), 1, + sym_expression, + STATE(95), 1, + sym__quote_string, + STATE(96), 1, + sym__block_string, + STATE(178), 1, + sym_comment, + STATE(334), 1, + sym__prefix_expression, + STATE(336), 1, + sym_method_index_expression, + ACTIONS(431), 2, + sym_number, + sym_vararg_expression, + ACTIONS(441), 2, + anon_sym_DASH, + anon_sym_not, + STATE(27), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(429), 3, + sym_nil, + sym_false, + sym_true, + STATE(28), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(439), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(102), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [14213] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(71), 1, + sym_expression, + STATE(179), 1, + sym_comment, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [14295] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(78), 1, + sym_expression, + STATE(180), 1, + sym_comment, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [14377] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(181), 1, + sym_comment, + STATE(215), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [14459] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(182), 1, + sym_comment, + STATE(209), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [14541] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(183), 1, + sym_comment, + STATE(217), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [14623] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(61), 1, + sym_expression, + STATE(184), 1, + sym_comment, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [14705] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(185), 1, + sym_comment, + STATE(204), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [14787] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(423), 1, + sym_identifier, + ACTIONS(425), 1, + anon_sym_LPAREN, + ACTIONS(427), 1, + anon_sym_function, + ACTIONS(433), 1, + anon_sym_DQUOTE, + ACTIONS(435), 1, + anon_sym_SQUOTE, + ACTIONS(437), 1, + anon_sym_LBRACE, + ACTIONS(443), 1, + sym__block_string_start, + STATE(69), 1, + sym_expression, + STATE(95), 1, + sym__quote_string, + STATE(96), 1, + sym__block_string, + STATE(186), 1, + sym_comment, + STATE(334), 1, + sym__prefix_expression, + STATE(336), 1, + sym_method_index_expression, + ACTIONS(431), 2, + sym_number, + sym_vararg_expression, + ACTIONS(441), 2, + anon_sym_DASH, + anon_sym_not, + STATE(27), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(429), 3, + sym_nil, + sym_false, + sym_true, + STATE(28), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(439), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(102), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [14869] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(187), 1, + sym_comment, + STATE(221), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [14951] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(188), 1, + sym_comment, + STATE(219), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [15033] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(423), 1, + sym_identifier, + ACTIONS(425), 1, + anon_sym_LPAREN, + ACTIONS(427), 1, + anon_sym_function, + ACTIONS(433), 1, + anon_sym_DQUOTE, + ACTIONS(435), 1, + anon_sym_SQUOTE, + ACTIONS(437), 1, + anon_sym_LBRACE, + ACTIONS(443), 1, + sym__block_string_start, + STATE(77), 1, + sym_expression, + STATE(95), 1, + sym__quote_string, + STATE(96), 1, + sym__block_string, + STATE(189), 1, + sym_comment, + STATE(334), 1, + sym__prefix_expression, + STATE(336), 1, + sym_method_index_expression, + ACTIONS(431), 2, + sym_number, + sym_vararg_expression, + ACTIONS(441), 2, + anon_sym_DASH, + anon_sym_not, + STATE(27), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(429), 3, + sym_nil, + sym_false, + sym_true, + STATE(28), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(439), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(102), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [15115] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(190), 1, + sym_comment, + STATE(218), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [15197] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(191), 1, + sym_comment, + STATE(220), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [15279] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(192), 1, + sym_comment, + STATE(222), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [15361] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(193), 1, + sym_comment, + STATE(224), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [15443] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(72), 1, + sym_expression, + STATE(194), 1, + sym_comment, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [15525] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + ACTIONS(447), 1, + anon_sym_LPAREN, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(195), 1, + sym_comment, + STATE(225), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [15607] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + ACTIONS(449), 1, + anon_sym_LPAREN, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(196), 1, + sym_comment, + STATE(228), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [15689] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + ACTIONS(451), 1, + anon_sym_LPAREN, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(197), 1, + sym_comment, + STATE(216), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [15771] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(423), 1, + sym_identifier, + ACTIONS(425), 1, + anon_sym_LPAREN, + ACTIONS(427), 1, + anon_sym_function, + ACTIONS(433), 1, + anon_sym_DQUOTE, + ACTIONS(435), 1, + anon_sym_SQUOTE, + ACTIONS(437), 1, + anon_sym_LBRACE, + ACTIONS(443), 1, + sym__block_string_start, + STATE(95), 1, + sym__quote_string, + STATE(96), 1, + sym__block_string, + STATE(108), 1, + sym_expression, + STATE(198), 1, + sym_comment, + STATE(334), 1, + sym__prefix_expression, + STATE(336), 1, + sym_method_index_expression, + ACTIONS(431), 2, + sym_number, + sym_vararg_expression, + ACTIONS(441), 2, + anon_sym_DASH, + anon_sym_not, + STATE(27), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(429), 3, + sym_nil, + sym_false, + sym_true, + STATE(28), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(439), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(102), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [15853] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + ACTIONS(453), 1, + anon_sym_LPAREN, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(199), 1, + sym_comment, + STATE(223), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [15935] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(200), 1, + sym_comment, + STATE(210), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [16017] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(201), 1, + sym_comment, + STATE(211), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [16099] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + ACTIONS(455), 1, + anon_sym_LPAREN, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(202), 1, + sym_comment, + STATE(216), 1, + sym_expression, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [16181] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(9), 1, + sym_identifier, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(369), 1, + anon_sym_function, + ACTIONS(375), 1, + anon_sym_DQUOTE, + ACTIONS(377), 1, + anon_sym_SQUOTE, + ACTIONS(379), 1, + anon_sym_LBRACE, + ACTIONS(385), 1, + sym__block_string_start, + STATE(48), 1, + sym_expression, + STATE(49), 1, + sym__block_string, + STATE(50), 1, + sym__quote_string, + STATE(203), 1, + sym_comment, + STATE(335), 1, + sym__prefix_expression, + STATE(339), 1, + sym_method_index_expression, + ACTIONS(373), 2, + sym_number, + sym_vararg_expression, + ACTIONS(383), 2, + anon_sym_DASH, + anon_sym_not, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + ACTIONS(371), 3, + sym_nil, + sym_false, + sym_true, + STATE(14), 3, + sym_variable, + sym_function_call, + sym_parenthesized_expression, + ACTIONS(381), 5, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + STATE(57), 5, + sym_string, + sym_function_definition, + sym_table_constructor, + sym_binary_expression, + sym_unary_expression, + [16263] = 20, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(411), 1, + anon_sym_or, + ACTIONS(413), 1, + anon_sym_and, + STATE(204), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(457), 3, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_RBRACE, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + [16337] = 20, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(411), 1, + anon_sym_or, + ACTIONS(413), 1, + anon_sym_and, + STATE(205), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(459), 3, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_RBRACE, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + [16411] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(407), 1, + anon_sym_COMMA, + ACTIONS(411), 1, + anon_sym_or, + ACTIONS(413), 1, + anon_sym_and, + ACTIONS(461), 1, + anon_sym_RPAREN, + STATE(206), 1, + sym_comment, + STATE(388), 1, + aux_sym__expression_list_repeat1, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + [16489] = 22, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(407), 1, + anon_sym_COMMA, + ACTIONS(411), 1, + anon_sym_or, + ACTIONS(413), 1, + anon_sym_and, + ACTIONS(463), 1, + anon_sym_RPAREN, + STATE(207), 1, + sym_comment, + STATE(401), 1, + aux_sym__expression_list_repeat1, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + [16567] = 20, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(411), 1, + anon_sym_or, + ACTIONS(413), 1, + anon_sym_and, + STATE(208), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(465), 3, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_RBRACE, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + [16641] = 21, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(411), 1, + anon_sym_or, + ACTIONS(413), 1, + anon_sym_and, + ACTIONS(467), 1, + anon_sym_COMMA, + ACTIONS(469), 1, + anon_sym_do, + STATE(209), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + [16716] = 20, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(411), 1, + anon_sym_or, + ACTIONS(413), 1, + anon_sym_and, + ACTIONS(471), 1, + anon_sym_RPAREN, + STATE(210), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + [16788] = 20, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(411), 1, + anon_sym_or, + ACTIONS(413), 1, + anon_sym_and, + ACTIONS(473), 1, + anon_sym_RPAREN, + STATE(211), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + [16860] = 20, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(411), 1, + anon_sym_or, + ACTIONS(413), 1, + anon_sym_and, + ACTIONS(475), 1, + anon_sym_then, + STATE(212), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + [16932] = 20, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(411), 1, + anon_sym_or, + ACTIONS(413), 1, + anon_sym_and, + ACTIONS(477), 1, + anon_sym_RPAREN, + STATE(213), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + [17004] = 20, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(411), 1, + anon_sym_or, + ACTIONS(413), 1, + anon_sym_and, + ACTIONS(479), 1, + anon_sym_RPAREN, + STATE(214), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + [17076] = 20, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(411), 1, + anon_sym_or, + ACTIONS(413), 1, + anon_sym_and, + ACTIONS(481), 1, + anon_sym_RPAREN, + STATE(215), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + [17148] = 20, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(411), 1, + anon_sym_or, + ACTIONS(413), 1, + anon_sym_and, + ACTIONS(483), 1, + anon_sym_do, + STATE(216), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + [17220] = 20, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(411), 1, + anon_sym_or, + ACTIONS(413), 1, + anon_sym_and, + ACTIONS(485), 1, + anon_sym_COMMA, + STATE(217), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + [17292] = 20, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(411), 1, + anon_sym_or, + ACTIONS(413), 1, + anon_sym_and, + ACTIONS(487), 1, + anon_sym_RPAREN, + STATE(218), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + [17364] = 20, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(411), 1, + anon_sym_or, + ACTIONS(413), 1, + anon_sym_and, + ACTIONS(489), 1, + anon_sym_RBRACK, + STATE(219), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + [17436] = 20, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(411), 1, + anon_sym_or, + ACTIONS(413), 1, + anon_sym_and, + ACTIONS(491), 1, + anon_sym_RPAREN, + STATE(220), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + [17508] = 20, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(411), 1, + anon_sym_or, + ACTIONS(413), 1, + anon_sym_and, + ACTIONS(493), 1, + anon_sym_do, + STATE(221), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + [17580] = 20, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(411), 1, + anon_sym_or, + ACTIONS(413), 1, + anon_sym_and, + ACTIONS(495), 1, + anon_sym_RPAREN, + STATE(222), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + [17652] = 20, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(411), 1, + anon_sym_or, + ACTIONS(413), 1, + anon_sym_and, + ACTIONS(497), 1, + anon_sym_then, + STATE(223), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + [17724] = 20, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(411), 1, + anon_sym_or, + ACTIONS(413), 1, + anon_sym_and, + ACTIONS(499), 1, + anon_sym_RBRACK, + STATE(224), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + [17796] = 20, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(411), 1, + anon_sym_or, + ACTIONS(413), 1, + anon_sym_and, + ACTIONS(501), 1, + anon_sym_do, + STATE(225), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + [17868] = 20, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(411), 1, + anon_sym_or, + ACTIONS(413), 1, + anon_sym_and, + ACTIONS(503), 1, + anon_sym_RBRACK, + STATE(226), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + [17940] = 7, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(116), 1, + anon_sym_COLON, + STATE(227), 1, + sym_comment, + ACTIONS(505), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(114), 7, + sym__block_string_start, + anon_sym_LPAREN, + anon_sym_DOT, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_LBRACE, + ACTIONS(507), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [17986] = 20, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(154), 1, + anon_sym_AMP, + ACTIONS(160), 1, + anon_sym_PLUS, + ACTIONS(162), 1, + anon_sym_DASH, + ACTIONS(166), 1, + anon_sym_SLASH, + ACTIONS(168), 1, + anon_sym_DOT_DOT, + ACTIONS(170), 1, + anon_sym_CARET, + ACTIONS(180), 1, + anon_sym_PIPE, + ACTIONS(182), 1, + anon_sym_TILDE, + ACTIONS(184), 1, + anon_sym_CARET_CARET, + ACTIONS(411), 1, + anon_sym_or, + ACTIONS(413), 1, + anon_sym_and, + ACTIONS(509), 1, + anon_sym_then, + STATE(228), 1, + sym_comment, + ACTIONS(156), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(186), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(158), 3, + anon_sym_GT_GT_GT, + anon_sym_LT_LT_GT, + anon_sym_GT_GT_LT, + ACTIONS(164), 4, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_PERCENT, + anon_sym_BSLASH, + ACTIONS(190), 5, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_TILDE_EQ, + anon_sym_BANG_EQ, + anon_sym_GT_EQ, + [18058] = 9, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(116), 1, + anon_sym_DOT, + ACTIONS(511), 1, + anon_sym_EQ, + ACTIONS(513), 1, + anon_sym_COMMA, + STATE(229), 1, + sym_comment, + STATE(402), 1, + aux_sym__variable_assignment_varlist_repeat1, + ACTIONS(114), 7, + sym__block_string_start, + anon_sym_LPAREN, + anon_sym_COLON, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_LBRACE, + ACTIONS(515), 16, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_BSLASH_EQ, + anon_sym_CARET_EQ, + anon_sym_DOT_DOT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_CARET_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_LT_LT_GT_EQ, + anon_sym_GT_GT_LT_EQ, + [18107] = 9, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(116), 1, + anon_sym_DOT, + ACTIONS(511), 1, + anon_sym_EQ, + ACTIONS(513), 1, + anon_sym_COMMA, + STATE(230), 1, + sym_comment, + STATE(402), 1, + aux_sym__variable_assignment_varlist_repeat1, + ACTIONS(114), 7, + sym__block_string_start, + anon_sym_LPAREN, + anon_sym_COLON, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_LBRACE, + ACTIONS(517), 16, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_BSLASH_EQ, + anon_sym_CARET_EQ, + anon_sym_DOT_DOT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_CARET_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_LT_LT_GT_EQ, + anon_sym_GT_GT_LT_EQ, + [18156] = 7, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(116), 1, + anon_sym_COLON, + STATE(231), 1, + sym_comment, + ACTIONS(505), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(114), 7, + sym__block_string_start, + anon_sym_LPAREN, + anon_sym_DOT, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_LBRACE, + ACTIONS(507), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [18201] = 9, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(523), 1, + anon_sym_COMMA, + ACTIONS(525), 1, + anon_sym_LT, + STATE(232), 1, + sym_comment, + STATE(239), 1, + sym__attrib, + STATE(241), 1, + aux_sym__att_name_list_repeat1, + ACTIONS(519), 7, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_EQ, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(521), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [18249] = 9, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(523), 1, + anon_sym_COMMA, + ACTIONS(525), 1, + anon_sym_LT, + STATE(233), 1, + sym_comment, + STATE(242), 1, + aux_sym__att_name_list_repeat1, + STATE(244), 1, + sym__attrib, + ACTIONS(527), 7, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_EQ, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(529), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [18297] = 7, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(525), 1, + anon_sym_LT, + STATE(234), 1, + sym_comment, + STATE(255), 1, + sym__attrib, + ACTIONS(531), 8, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_EQ, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(533), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [18340] = 9, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(535), 1, + anon_sym_COMMA, + ACTIONS(537), 1, + anon_sym_LT, + STATE(235), 1, + sym_comment, + STATE(250), 1, + sym__attrib, + STATE(251), 1, + aux_sym__att_name_list_repeat1, + ACTIONS(527), 7, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_EQ, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(529), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [18387] = 9, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(535), 1, + anon_sym_COMMA, + ACTIONS(537), 1, + anon_sym_LT, + STATE(236), 1, + sym_comment, + STATE(249), 1, + aux_sym__att_name_list_repeat1, + STATE(256), 1, + sym__attrib, + ACTIONS(519), 7, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_EQ, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(521), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [18434] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(543), 1, + anon_sym_COMMA, + STATE(237), 2, + sym_comment, + aux_sym__att_name_list_repeat1, + ACTIONS(539), 7, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_EQ, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(541), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [18474] = 7, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(523), 1, + anon_sym_COMMA, + STATE(237), 1, + aux_sym__att_name_list_repeat1, + STATE(238), 1, + sym_comment, + ACTIONS(546), 7, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_EQ, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(548), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [18516] = 7, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(523), 1, + anon_sym_COMMA, + STATE(238), 1, + aux_sym__att_name_list_repeat1, + STATE(239), 1, + sym_comment, + ACTIONS(550), 7, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_EQ, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(552), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [18558] = 7, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(537), 1, + anon_sym_LT, + STATE(240), 1, + sym_comment, + STATE(264), 1, + sym__attrib, + ACTIONS(531), 8, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_EQ, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(533), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [18600] = 7, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(523), 1, + anon_sym_COMMA, + STATE(237), 1, + aux_sym__att_name_list_repeat1, + STATE(241), 1, + sym_comment, + ACTIONS(554), 7, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_EQ, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(556), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [18642] = 7, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(523), 1, + anon_sym_COMMA, + STATE(237), 1, + aux_sym__att_name_list_repeat1, + STATE(242), 1, + sym_comment, + ACTIONS(558), 7, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_EQ, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(560), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [18684] = 7, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(523), 1, + anon_sym_COMMA, + STATE(237), 1, + aux_sym__att_name_list_repeat1, + STATE(243), 1, + sym_comment, + ACTIONS(562), 7, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_EQ, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(564), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [18726] = 7, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(523), 1, + anon_sym_COMMA, + STATE(243), 1, + aux_sym__att_name_list_repeat1, + STATE(244), 1, + sym_comment, + ACTIONS(566), 7, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_EQ, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(568), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [18768] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(574), 1, + anon_sym_COMMA, + STATE(245), 2, + sym_comment, + aux_sym__variable_assignment_explist_repeat1, + ACTIONS(570), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(572), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [18807] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(577), 1, + anon_sym_COMMA, + STATE(246), 2, + sym_comment, + aux_sym__att_name_list_repeat1, + ACTIONS(539), 7, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_EQ, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(541), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [18846] = 7, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(220), 1, + anon_sym_COMMA, + STATE(245), 1, + aux_sym__variable_assignment_explist_repeat1, + STATE(247), 1, + sym_comment, + ACTIONS(580), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(582), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [18887] = 7, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(535), 1, + anon_sym_COMMA, + STATE(246), 1, + aux_sym__att_name_list_repeat1, + STATE(248), 1, + sym_comment, + ACTIONS(546), 7, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_EQ, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(548), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [18928] = 7, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(535), 1, + anon_sym_COMMA, + STATE(246), 1, + aux_sym__att_name_list_repeat1, + STATE(249), 1, + sym_comment, + ACTIONS(554), 7, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_EQ, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(556), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [18969] = 7, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(535), 1, + anon_sym_COMMA, + STATE(250), 1, + sym_comment, + STATE(257), 1, + aux_sym__att_name_list_repeat1, + ACTIONS(566), 7, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_EQ, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(568), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [19010] = 7, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(535), 1, + anon_sym_COMMA, + STATE(246), 1, + aux_sym__att_name_list_repeat1, + STATE(251), 1, + sym_comment, + ACTIONS(558), 7, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_EQ, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(560), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [19051] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(588), 1, + anon_sym_COMMA, + STATE(252), 2, + sym_comment, + aux_sym_print_shorthand_statement_repeat1, + ACTIONS(584), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(586), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [19090] = 7, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(212), 1, + anon_sym_COMMA, + STATE(252), 1, + aux_sym_print_shorthand_statement_repeat1, + STATE(253), 1, + sym_comment, + ACTIONS(591), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(593), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [19131] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(254), 1, + sym_comment, + ACTIONS(595), 8, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_EQ, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(597), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [19168] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(255), 1, + sym_comment, + ACTIONS(599), 8, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_EQ, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(601), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [19205] = 7, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(535), 1, + anon_sym_COMMA, + STATE(248), 1, + aux_sym__att_name_list_repeat1, + STATE(256), 1, + sym_comment, + ACTIONS(550), 7, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_EQ, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(552), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [19246] = 7, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(535), 1, + anon_sym_COMMA, + STATE(246), 1, + aux_sym__att_name_list_repeat1, + STATE(257), 1, + sym_comment, + ACTIONS(562), 7, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_EQ, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(564), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [19287] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(258), 1, + sym_comment, + ACTIONS(595), 8, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_EQ, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(597), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [19323] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(607), 1, + anon_sym_EQ, + STATE(259), 1, + sym_comment, + ACTIONS(603), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(605), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [19361] = 7, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(222), 1, + anon_sym_COMMA, + STATE(260), 1, + sym_comment, + STATE(262), 1, + aux_sym_print_shorthand_statement_repeat1, + ACTIONS(591), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(593), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [19401] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(609), 1, + anon_sym_COMMA, + STATE(261), 2, + sym_comment, + aux_sym__variable_assignment_explist_repeat1, + ACTIONS(570), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(572), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [19439] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(612), 1, + anon_sym_COMMA, + STATE(262), 2, + sym_comment, + aux_sym_print_shorthand_statement_repeat1, + ACTIONS(584), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(586), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [19477] = 7, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(256), 1, + anon_sym_COMMA, + STATE(261), 1, + aux_sym__variable_assignment_explist_repeat1, + STATE(263), 1, + sym_comment, + ACTIONS(580), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(582), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [19517] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(264), 1, + sym_comment, + ACTIONS(599), 8, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_EQ, + anon_sym_COMMA, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(601), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [19553] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(265), 1, + sym_comment, + ACTIONS(615), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(617), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [19588] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(266), 1, + sym_comment, + ACTIONS(619), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(621), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [19623] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(267), 1, + sym_comment, + ACTIONS(623), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(625), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [19658] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(268), 1, + sym_comment, + ACTIONS(627), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(629), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [19693] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(631), 1, + anon_sym_EQ, + STATE(269), 1, + sym_comment, + ACTIONS(603), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(605), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [19730] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(270), 1, + sym_comment, + ACTIONS(633), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(635), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [19765] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(271), 1, + sym_comment, + ACTIONS(637), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(639), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [19800] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(272), 1, + sym_comment, + ACTIONS(641), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(643), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [19835] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(273), 1, + sym_comment, + ACTIONS(645), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(647), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [19870] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(274), 1, + sym_comment, + ACTIONS(649), 7, + anon_sym_function, + sym_nil, + sym_false, + sym_true, + anon_sym_DASH, + anon_sym_not, + sym_identifier, + ACTIONS(651), 14, + sym__block_string_start, + anon_sym_LPAREN, + sym_number, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + sym_vararg_expression, + anon_sym_LBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_TILDE, + anon_sym_PERCENT, + anon_sym_POUND, + anon_sym_AT, + anon_sym_DOLLAR, + [19905] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(275), 1, + sym_comment, + ACTIONS(505), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(507), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [19940] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(276), 1, + sym_comment, + ACTIONS(653), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(655), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [19975] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(277), 1, + sym_comment, + ACTIONS(657), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(659), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [20010] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(278), 1, + sym_comment, + ACTIONS(661), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(663), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [20045] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(279), 1, + sym_comment, + ACTIONS(665), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(667), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [20080] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(280), 1, + sym_comment, + ACTIONS(669), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(671), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [20115] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(281), 1, + sym_comment, + ACTIONS(673), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(675), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [20150] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(282), 1, + sym_comment, + ACTIONS(677), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(679), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [20185] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(283), 1, + sym_comment, + ACTIONS(681), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(683), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [20220] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(284), 1, + sym_comment, + ACTIONS(685), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(687), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [20255] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(285), 1, + sym_comment, + ACTIONS(689), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(691), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [20290] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(286), 1, + sym_comment, + ACTIONS(693), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(695), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [20325] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(287), 1, + sym_comment, + ACTIONS(697), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(699), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [20360] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(288), 1, + sym_comment, + ACTIONS(701), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(703), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [20395] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(289), 1, + sym_comment, + ACTIONS(705), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(707), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [20430] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(290), 1, + sym_comment, + ACTIONS(709), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(711), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [20465] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(291), 1, + sym_comment, + ACTIONS(713), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(715), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [20500] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(292), 1, + sym_comment, + ACTIONS(717), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(719), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [20535] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(293), 1, + sym_comment, + ACTIONS(721), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(723), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [20570] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(294), 1, + sym_comment, + ACTIONS(725), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(727), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [20605] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(295), 1, + sym_comment, + ACTIONS(729), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(731), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [20640] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(296), 1, + sym_comment, + ACTIONS(733), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(735), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [20675] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(297), 1, + sym_comment, + ACTIONS(737), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(739), 15, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_elseif, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [20710] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(298), 1, + sym_comment, + ACTIONS(685), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(687), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [20744] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(299), 1, + sym_comment, + ACTIONS(637), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(639), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [20778] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(300), 1, + sym_comment, + ACTIONS(657), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(659), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [20812] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(301), 1, + sym_comment, + ACTIONS(661), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(663), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [20846] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(302), 1, + sym_comment, + ACTIONS(669), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(671), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [20880] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(303), 1, + sym_comment, + ACTIONS(673), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(675), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [20914] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(304), 1, + sym_comment, + ACTIONS(505), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(507), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [20948] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(305), 1, + sym_comment, + ACTIONS(645), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(647), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [20982] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(306), 1, + sym_comment, + ACTIONS(689), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(691), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [21016] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(307), 1, + sym_comment, + ACTIONS(697), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(699), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [21050] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(308), 1, + sym_comment, + ACTIONS(615), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(617), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [21084] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(309), 1, + sym_comment, + ACTIONS(701), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(703), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [21118] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(310), 1, + sym_comment, + ACTIONS(705), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(707), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [21152] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(311), 1, + sym_comment, + ACTIONS(717), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(719), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [21186] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(312), 1, + sym_comment, + ACTIONS(733), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(735), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [21220] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(313), 1, + sym_comment, + ACTIONS(737), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(739), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [21254] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(314), 1, + sym_comment, + ACTIONS(665), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(667), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [21288] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(315), 1, + sym_comment, + ACTIONS(619), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(621), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [21322] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(316), 1, + sym_comment, + ACTIONS(623), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(625), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [21356] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(317), 1, + sym_comment, + ACTIONS(721), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(723), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [21390] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(318), 1, + sym_comment, + ACTIONS(725), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(727), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [21424] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(319), 1, + sym_comment, + ACTIONS(729), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(731), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [21458] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(745), 1, + anon_sym_else, + STATE(320), 1, + sym_comment, + ACTIONS(741), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(743), 13, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [21494] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(747), 1, + anon_sym_else, + STATE(321), 1, + sym_comment, + ACTIONS(741), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(743), 13, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [21530] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(322), 1, + sym_comment, + ACTIONS(709), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(711), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [21564] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(323), 1, + sym_comment, + ACTIONS(713), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(715), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [21598] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(324), 1, + sym_comment, + ACTIONS(627), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(629), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [21632] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(325), 1, + sym_comment, + ACTIONS(633), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(635), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [21666] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(326), 1, + sym_comment, + ACTIONS(641), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(643), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [21700] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(327), 1, + sym_comment, + ACTIONS(677), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(679), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [21734] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(328), 1, + sym_comment, + ACTIONS(681), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(683), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [21768] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(329), 1, + sym_comment, + ACTIONS(653), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(655), 14, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_until, + anon_sym_if, + anon_sym_else, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [21802] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(749), 1, + anon_sym_else, + STATE(330), 1, + sym_comment, + ACTIONS(741), 5, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(743), 13, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_if, + anon_sym_elseif, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [21837] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(331), 1, + sym_comment, + ACTIONS(753), 5, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(751), 12, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_if, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [21868] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(332), 1, + sym_comment, + ACTIONS(757), 5, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + aux_sym_include_statement_token1, + ACTIONS(755), 12, + anon_sym_return, + sym_break_statement, + anon_sym_goto, + anon_sym_do, + anon_sym_end, + anon_sym_while, + anon_sym_repeat, + anon_sym_if, + anon_sym_for, + anon_sym_function, + anon_sym_local, + sym_identifier, + [21899] = 15, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(759), 1, + anon_sym_LPAREN, + ACTIONS(761), 1, + anon_sym_DOT, + ACTIONS(763), 1, + anon_sym_COLON, + ACTIONS(765), 1, + anon_sym_DQUOTE, + ACTIONS(767), 1, + anon_sym_SQUOTE, + ACTIONS(769), 1, + anon_sym_LBRACK, + ACTIONS(771), 1, + anon_sym_LBRACE, + ACTIONS(773), 1, + sym__block_string_start, + STATE(30), 1, + sym_arguments, + STATE(37), 1, + sym__quote_string, + STATE(38), 1, + sym__block_string, + STATE(333), 1, + sym_comment, + STATE(29), 2, + sym_string, + sym_table_constructor, + [21946] = 15, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(759), 1, + anon_sym_LPAREN, + ACTIONS(763), 1, + anon_sym_COLON, + ACTIONS(765), 1, + anon_sym_DQUOTE, + ACTIONS(767), 1, + anon_sym_SQUOTE, + ACTIONS(771), 1, + anon_sym_LBRACE, + ACTIONS(773), 1, + sym__block_string_start, + ACTIONS(775), 1, + anon_sym_DOT, + ACTIONS(777), 1, + anon_sym_LBRACK, + STATE(30), 1, + sym_arguments, + STATE(37), 1, + sym__quote_string, + STATE(38), 1, + sym__block_string, + STATE(334), 1, + sym_comment, + STATE(29), 2, + sym_string, + sym_table_constructor, + [21993] = 15, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(761), 1, + anon_sym_DOT, + ACTIONS(763), 1, + anon_sym_COLON, + ACTIONS(769), 1, + anon_sym_LBRACK, + ACTIONS(779), 1, + anon_sym_LPAREN, + ACTIONS(781), 1, + anon_sym_DQUOTE, + ACTIONS(783), 1, + anon_sym_SQUOTE, + ACTIONS(785), 1, + anon_sym_LBRACE, + ACTIONS(787), 1, + sym__block_string_start, + STATE(11), 1, + sym_arguments, + STATE(21), 1, + sym__block_string, + STATE(22), 1, + sym__quote_string, + STATE(335), 1, + sym_comment, + STATE(12), 2, + sym_string, + sym_table_constructor, + [22040] = 12, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(759), 1, + anon_sym_LPAREN, + ACTIONS(765), 1, + anon_sym_DQUOTE, + ACTIONS(767), 1, + anon_sym_SQUOTE, + ACTIONS(771), 1, + anon_sym_LBRACE, + ACTIONS(773), 1, + sym__block_string_start, + STATE(30), 1, + sym_arguments, + STATE(37), 1, + sym__quote_string, + STATE(38), 1, + sym__block_string, + STATE(336), 1, + sym_comment, + STATE(29), 2, + sym_string, + sym_table_constructor, + [22078] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(417), 1, + anon_sym_else, + ACTIONS(789), 1, + anon_sym_COMMA, + STATE(337), 2, + sym_comment, + aux_sym__expression_list_repeat1, + ACTIONS(415), 7, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_do, + anon_sym_end, + anon_sym_RPAREN, + anon_sym_until, + anon_sym_elseif, + [22104] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(338), 1, + sym_comment, + ACTIONS(792), 2, + anon_sym_EQ, + anon_sym_COMMA, + ACTIONS(114), 8, + sym__block_string_start, + anon_sym_LPAREN, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_LBRACE, + [22128] = 12, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(779), 1, + anon_sym_LPAREN, + ACTIONS(781), 1, + anon_sym_DQUOTE, + ACTIONS(783), 1, + anon_sym_SQUOTE, + ACTIONS(785), 1, + anon_sym_LBRACE, + ACTIONS(787), 1, + sym__block_string_start, + STATE(11), 1, + sym_arguments, + STATE(21), 1, + sym__block_string, + STATE(22), 1, + sym__quote_string, + STATE(339), 1, + sym_comment, + STATE(12), 2, + sym_string, + sym_table_constructor, + [22166] = 10, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(27), 1, + anon_sym_LPAREN, + ACTIONS(794), 1, + sym_identifier, + STATE(335), 1, + sym__prefix_expression, + STATE(338), 1, + sym_variable, + STATE(339), 1, + sym_method_index_expression, + STATE(340), 1, + sym_comment, + STATE(2), 2, + sym_bracket_index_expression, + sym_dot_index_expression, + STATE(342), 2, + sym_function_call, + sym_parenthesized_expression, + [22199] = 7, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(407), 1, + anon_sym_COMMA, + ACTIONS(798), 1, + anon_sym_else, + STATE(337), 1, + aux_sym__expression_list_repeat1, + STATE(341), 1, + sym_comment, + ACTIONS(796), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_do, + anon_sym_end, + anon_sym_until, + anon_sym_elseif, + [22226] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(342), 1, + sym_comment, + ACTIONS(114), 8, + sym__block_string_start, + anon_sym_LPAREN, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACK, + anon_sym_LBRACE, + [22246] = 9, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(525), 1, + anon_sym_LT, + ACTIONS(800), 1, + sym_identifier, + ACTIONS(802), 1, + anon_sym_function, + STATE(259), 1, + sym__att_name_list, + STATE(271), 1, + sym__variable_assignment, + STATE(343), 1, + sym_comment, + STATE(472), 1, + sym__attrib, + [22274] = 9, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(204), 1, + anon_sym_else, + ACTIONS(804), 1, + anon_sym_end, + ACTIONS(806), 1, + anon_sym_elseif, + STATE(344), 1, + sym_comment, + STATE(359), 1, + aux_sym_if_statement_repeat1, + STATE(405), 1, + sym_elseif_statement, + STATE(454), 1, + sym_else_statement, + [22302] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(810), 1, + anon_sym_SEMI, + ACTIONS(812), 1, + anon_sym_else, + STATE(345), 1, + sym_comment, + ACTIONS(808), 4, + ts_builtin_sym_end, + anon_sym_end, + anon_sym_until, + anon_sym_elseif, + [22324] = 9, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(204), 1, + anon_sym_else, + ACTIONS(806), 1, + anon_sym_elseif, + ACTIONS(814), 1, + anon_sym_end, + STATE(346), 1, + sym_comment, + STATE(350), 1, + aux_sym_if_statement_repeat1, + STATE(405), 1, + sym_elseif_statement, + STATE(427), 1, + sym_else_statement, + [22352] = 9, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(525), 1, + anon_sym_LT, + ACTIONS(816), 1, + sym_identifier, + ACTIONS(818), 1, + anon_sym_function, + STATE(269), 1, + sym__att_name_list, + STATE(299), 1, + sym__variable_assignment, + STATE(347), 1, + sym_comment, + STATE(416), 1, + sym__attrib, + [22380] = 9, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(204), 1, + anon_sym_else, + ACTIONS(806), 1, + anon_sym_elseif, + ACTIONS(820), 1, + anon_sym_end, + STATE(348), 1, + sym_comment, + STATE(351), 1, + aux_sym_if_statement_repeat1, + STATE(405), 1, + sym_elseif_statement, + STATE(441), 1, + sym_else_statement, + [22408] = 9, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(204), 1, + anon_sym_else, + ACTIONS(806), 1, + anon_sym_elseif, + ACTIONS(822), 1, + anon_sym_end, + STATE(349), 1, + sym_comment, + STATE(359), 1, + aux_sym_if_statement_repeat1, + STATE(405), 1, + sym_elseif_statement, + STATE(443), 1, + sym_else_statement, + [22436] = 9, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(204), 1, + anon_sym_else, + ACTIONS(806), 1, + anon_sym_elseif, + ACTIONS(824), 1, + anon_sym_end, + STATE(350), 1, + sym_comment, + STATE(359), 1, + aux_sym_if_statement_repeat1, + STATE(405), 1, + sym_elseif_statement, + STATE(484), 1, + sym_else_statement, + [22464] = 9, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(204), 1, + anon_sym_else, + ACTIONS(806), 1, + anon_sym_elseif, + ACTIONS(826), 1, + anon_sym_end, + STATE(351), 1, + sym_comment, + STATE(359), 1, + aux_sym_if_statement_repeat1, + STATE(405), 1, + sym_elseif_statement, + STATE(444), 1, + sym_else_statement, + [22492] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(812), 1, + anon_sym_else, + STATE(352), 1, + sym_comment, + ACTIONS(808), 4, + ts_builtin_sym_end, + anon_sym_end, + anon_sym_until, + anon_sym_elseif, + [22511] = 7, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(830), 1, + anon_sym_RBRACE, + STATE(133), 1, + sym__field_sep, + STATE(353), 1, + sym_comment, + STATE(357), 1, + aux_sym__field_list_repeat1, + ACTIONS(828), 2, + anon_sym_SEMI, + anon_sym_COMMA, + [22534] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(834), 1, + anon_sym_else, + STATE(354), 1, + sym_comment, + ACTIONS(832), 4, + ts_builtin_sym_end, + anon_sym_end, + anon_sym_until, + anon_sym_elseif, + [22553] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(355), 1, + sym_comment, + ACTIONS(836), 5, + sym__block_string_start, + anon_sym_LPAREN, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LBRACE, + [22570] = 8, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(838), 1, + sym_identifier, + STATE(356), 1, + sym_comment, + STATE(393), 1, + sym__function_name_dot_index_expression, + STATE(398), 1, + sym__function_name, + STATE(406), 1, + sym__function_name_prefix_expression, + STATE(417), 1, + sym__function_name_method_index_expression, + [22595] = 7, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(403), 1, + anon_sym_RBRACE, + STATE(132), 1, + sym__field_sep, + STATE(357), 1, + sym_comment, + STATE(358), 1, + aux_sym__field_list_repeat1, + ACTIONS(828), 2, + anon_sym_SEMI, + anon_sym_COMMA, + [22618] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(843), 1, + anon_sym_RBRACE, + STATE(135), 1, + sym__field_sep, + ACTIONS(840), 2, + anon_sym_SEMI, + anon_sym_COMMA, + STATE(358), 2, + sym_comment, + aux_sym__field_list_repeat1, + [22639] = 7, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(845), 1, + anon_sym_end, + ACTIONS(847), 1, + anon_sym_elseif, + ACTIONS(850), 1, + anon_sym_else, + STATE(405), 1, + sym_elseif_statement, + STATE(359), 2, + sym_comment, + aux_sym_if_statement_repeat1, + [22662] = 8, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(838), 1, + sym_identifier, + STATE(360), 1, + sym_comment, + STATE(386), 1, + sym__function_name, + STATE(393), 1, + sym__function_name_dot_index_expression, + STATE(406), 1, + sym__function_name_prefix_expression, + STATE(417), 1, + sym__function_name_method_index_expression, + [22687] = 8, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(852), 1, + sym_identifier, + ACTIONS(854), 1, + anon_sym_RPAREN, + ACTIONS(856), 1, + sym_vararg_expression, + STATE(361), 1, + sym_comment, + STATE(442), 1, + sym__parameter_list, + STATE(457), 1, + sym__vararg_parameter, + [22712] = 6, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(858), 1, + anon_sym_DQUOTE, + ACTIONS(862), 1, + anon_sym_DASH_DASH, + STATE(362), 1, + sym_comment, + STATE(366), 1, + aux_sym__doublequote_string_content, + ACTIONS(860), 2, + aux_sym__doublequote_string_content_token1, + sym_escape_sequence, + [22732] = 6, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(862), 1, + anon_sym_DASH_DASH, + ACTIONS(864), 1, + anon_sym_SQUOTE, + STATE(363), 1, + sym_comment, + STATE(369), 1, + aux_sym__singlequote_string_content, + ACTIONS(866), 2, + aux_sym__singlequote_string_content_token1, + sym_escape_sequence, + [22752] = 7, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(868), 1, + anon_sym_EQ, + ACTIONS(870), 1, + anon_sym_COMMA, + ACTIONS(872), 1, + anon_sym_in, + STATE(364), 1, + sym_comment, + STATE(407), 1, + aux_sym__name_list_repeat1, + [22774] = 6, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(858), 1, + anon_sym_SQUOTE, + ACTIONS(862), 1, + anon_sym_DASH_DASH, + STATE(365), 1, + sym_comment, + STATE(369), 1, + aux_sym__singlequote_string_content, + ACTIONS(866), 2, + aux_sym__singlequote_string_content_token1, + sym_escape_sequence, + [22794] = 5, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(862), 1, + anon_sym_DASH_DASH, + ACTIONS(874), 1, + anon_sym_DQUOTE, + ACTIONS(876), 2, + aux_sym__doublequote_string_content_token1, + sym_escape_sequence, + STATE(366), 2, + aux_sym__doublequote_string_content, + sym_comment, + [22812] = 6, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(862), 1, + anon_sym_DASH_DASH, + ACTIONS(879), 1, + anon_sym_SQUOTE, + STATE(363), 1, + aux_sym__singlequote_string_content, + STATE(367), 1, + sym_comment, + ACTIONS(866), 2, + aux_sym__singlequote_string_content_token1, + sym_escape_sequence, + [22832] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(881), 1, + anon_sym_COMMA, + ACTIONS(884), 2, + anon_sym_RPAREN, + anon_sym_in, + STATE(368), 2, + sym_comment, + aux_sym__name_list_repeat1, + [22850] = 5, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(862), 1, + anon_sym_DASH_DASH, + ACTIONS(886), 1, + anon_sym_SQUOTE, + ACTIONS(888), 2, + aux_sym__singlequote_string_content_token1, + sym_escape_sequence, + STATE(369), 2, + aux_sym__singlequote_string_content, + sym_comment, + [22868] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(891), 1, + sym_identifier, + STATE(370), 1, + sym_comment, + STATE(446), 1, + sym__name_list, + STATE(415), 2, + sym_for_generic_clause, + sym_for_numeric_clause, + [22888] = 6, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(862), 1, + anon_sym_DASH_DASH, + ACTIONS(893), 1, + anon_sym_DQUOTE, + STATE(371), 1, + sym_comment, + STATE(373), 1, + aux_sym__doublequote_string_content, + ACTIONS(860), 2, + aux_sym__doublequote_string_content_token1, + sym_escape_sequence, + [22908] = 6, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(862), 1, + anon_sym_DASH_DASH, + ACTIONS(893), 1, + anon_sym_SQUOTE, + STATE(372), 1, + sym_comment, + STATE(374), 1, + aux_sym__singlequote_string_content, + ACTIONS(866), 2, + aux_sym__singlequote_string_content_token1, + sym_escape_sequence, + [22928] = 6, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(862), 1, + anon_sym_DASH_DASH, + ACTIONS(895), 1, + anon_sym_DQUOTE, + STATE(366), 1, + aux_sym__doublequote_string_content, + STATE(373), 1, + sym_comment, + ACTIONS(860), 2, + aux_sym__doublequote_string_content_token1, + sym_escape_sequence, + [22948] = 6, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(862), 1, + anon_sym_DASH_DASH, + ACTIONS(895), 1, + anon_sym_SQUOTE, + STATE(369), 1, + aux_sym__singlequote_string_content, + STATE(374), 1, + sym_comment, + ACTIONS(866), 2, + aux_sym__singlequote_string_content_token1, + sym_escape_sequence, + [22968] = 6, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(862), 1, + anon_sym_DASH_DASH, + ACTIONS(897), 1, + anon_sym_DQUOTE, + STATE(375), 1, + sym_comment, + STATE(377), 1, + aux_sym__doublequote_string_content, + ACTIONS(860), 2, + aux_sym__doublequote_string_content_token1, + sym_escape_sequence, + [22988] = 6, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(862), 1, + anon_sym_DASH_DASH, + ACTIONS(897), 1, + anon_sym_SQUOTE, + STATE(376), 1, + sym_comment, + STATE(378), 1, + aux_sym__singlequote_string_content, + ACTIONS(866), 2, + aux_sym__singlequote_string_content_token1, + sym_escape_sequence, + [23008] = 6, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(862), 1, + anon_sym_DASH_DASH, + ACTIONS(899), 1, + anon_sym_DQUOTE, + STATE(366), 1, + aux_sym__doublequote_string_content, + STATE(377), 1, + sym_comment, + ACTIONS(860), 2, + aux_sym__doublequote_string_content_token1, + sym_escape_sequence, + [23028] = 6, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(862), 1, + anon_sym_DASH_DASH, + ACTIONS(899), 1, + anon_sym_SQUOTE, + STATE(369), 1, + aux_sym__singlequote_string_content, + STATE(378), 1, + sym_comment, + ACTIONS(866), 2, + aux_sym__singlequote_string_content_token1, + sym_escape_sequence, + [23048] = 6, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(862), 1, + anon_sym_DASH_DASH, + ACTIONS(901), 1, + anon_sym_DQUOTE, + STATE(362), 1, + aux_sym__doublequote_string_content, + STATE(379), 1, + sym_comment, + ACTIONS(860), 2, + aux_sym__doublequote_string_content_token1, + sym_escape_sequence, + [23068] = 6, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(862), 1, + anon_sym_DASH_DASH, + ACTIONS(901), 1, + anon_sym_SQUOTE, + STATE(365), 1, + aux_sym__singlequote_string_content, + STATE(380), 1, + sym_comment, + ACTIONS(866), 2, + aux_sym__singlequote_string_content_token1, + sym_escape_sequence, + [23088] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(268), 1, + anon_sym_else, + STATE(381), 1, + sym_comment, + ACTIONS(903), 3, + anon_sym_end, + anon_sym_until, + anon_sym_elseif, + [23106] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(907), 1, + anon_sym_else, + STATE(382), 1, + sym_comment, + ACTIONS(905), 3, + anon_sym_end, + anon_sym_until, + anon_sym_elseif, + [23124] = 6, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(862), 1, + anon_sym_DASH_DASH, + ACTIONS(879), 1, + anon_sym_DQUOTE, + STATE(383), 1, + sym_comment, + STATE(385), 1, + aux_sym__doublequote_string_content, + ACTIONS(860), 2, + aux_sym__doublequote_string_content_token1, + sym_escape_sequence, + [23144] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(891), 1, + sym_identifier, + STATE(384), 1, + sym_comment, + STATE(446), 1, + sym__name_list, + STATE(467), 2, + sym_for_generic_clause, + sym_for_numeric_clause, + [23164] = 6, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(862), 1, + anon_sym_DASH_DASH, + ACTIONS(864), 1, + anon_sym_DQUOTE, + STATE(366), 1, + aux_sym__doublequote_string_content, + STATE(385), 1, + sym_comment, + ACTIONS(860), 2, + aux_sym__doublequote_string_content_token1, + sym_escape_sequence, + [23184] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(909), 1, + anon_sym_LPAREN, + STATE(115), 1, + sym_parameters, + STATE(324), 1, + sym__function_body, + STATE(386), 1, + sym_comment, + [23203] = 5, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(862), 1, + anon_sym_DASH_DASH, + ACTIONS(911), 1, + anon_sym_DQUOTE, + STATE(387), 1, + sym_comment, + ACTIONS(913), 2, + aux_sym__doublequote_string_content_token1, + sym_escape_sequence, + [23220] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(407), 1, + anon_sym_COMMA, + ACTIONS(915), 1, + anon_sym_RPAREN, + STATE(337), 1, + aux_sym__expression_list_repeat1, + STATE(388), 1, + sym_comment, + [23239] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(856), 1, + sym_vararg_expression, + ACTIONS(917), 1, + sym_identifier, + STATE(389), 1, + sym_comment, + STATE(475), 1, + sym__vararg_parameter, + [23258] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(919), 1, + anon_sym_COMMA, + ACTIONS(921), 1, + anon_sym_RPAREN, + STATE(368), 1, + aux_sym__name_list_repeat1, + STATE(390), 1, + sym_comment, + [23277] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(391), 1, + sym_comment, + ACTIONS(923), 3, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_in, + [23292] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(392), 1, + sym_comment, + ACTIONS(843), 3, + anon_sym_SEMI, + anon_sym_COMMA, + anon_sym_RBRACE, + [23307] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(393), 1, + sym_comment, + ACTIONS(925), 3, + anon_sym_LPAREN, + anon_sym_DOT, + anon_sym_COLON, + [23322] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(909), 1, + anon_sym_LPAREN, + STATE(76), 1, + sym__function_body, + STATE(115), 1, + sym_parameters, + STATE(394), 1, + sym_comment, + [23341] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(395), 1, + sym_comment, + ACTIONS(927), 3, + anon_sym_LPAREN, + anon_sym_DOT, + anon_sym_COLON, + [23356] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(929), 1, + anon_sym_EQ, + ACTIONS(931), 1, + anon_sym_COMMA, + STATE(396), 2, + sym_comment, + aux_sym__variable_assignment_varlist_repeat1, + [23373] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(909), 1, + anon_sym_LPAREN, + STATE(115), 1, + sym_parameters, + STATE(302), 1, + sym__function_body, + STATE(397), 1, + sym_comment, + [23392] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(909), 1, + anon_sym_LPAREN, + STATE(107), 1, + sym_parameters, + STATE(268), 1, + sym__function_body, + STATE(398), 1, + sym_comment, + [23411] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(909), 1, + anon_sym_LPAREN, + STATE(51), 1, + sym__function_body, + STATE(107), 1, + sym_parameters, + STATE(399), 1, + sym_comment, + [23430] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(934), 1, + anon_sym_COMMA, + ACTIONS(936), 1, + anon_sym_RPAREN, + STATE(390), 1, + aux_sym__name_list_repeat1, + STATE(400), 1, + sym_comment, + [23449] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(407), 1, + anon_sym_COMMA, + ACTIONS(938), 1, + anon_sym_RPAREN, + STATE(337), 1, + aux_sym__expression_list_repeat1, + STATE(401), 1, + sym_comment, + [23468] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(513), 1, + anon_sym_COMMA, + ACTIONS(940), 1, + anon_sym_EQ, + STATE(396), 1, + aux_sym__variable_assignment_varlist_repeat1, + STATE(402), 1, + sym_comment, + [23487] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + STATE(403), 1, + sym_comment, + ACTIONS(942), 3, + anon_sym_LPAREN, + anon_sym_DOT, + anon_sym_COLON, + [23502] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(909), 1, + anon_sym_LPAREN, + STATE(107), 1, + sym_parameters, + STATE(280), 1, + sym__function_body, + STATE(404), 1, + sym_comment, + [23521] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(946), 1, + anon_sym_else, + STATE(405), 1, + sym_comment, + ACTIONS(944), 2, + anon_sym_end, + anon_sym_elseif, + [23538] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(948), 1, + anon_sym_LPAREN, + ACTIONS(950), 1, + anon_sym_DOT, + ACTIONS(952), 1, + anon_sym_COLON, + STATE(406), 1, + sym_comment, + [23557] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(870), 1, + anon_sym_COMMA, + ACTIONS(954), 1, + anon_sym_in, + STATE(368), 1, + aux_sym__name_list_repeat1, + STATE(407), 1, + sym_comment, + [23576] = 5, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(862), 1, + anon_sym_DASH_DASH, + ACTIONS(956), 1, + anon_sym_SQUOTE, + STATE(408), 1, + sym_comment, + ACTIONS(958), 2, + aux_sym__singlequote_string_content_token1, + sym_escape_sequence, + [23593] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(962), 1, + anon_sym_else, + STATE(409), 1, + sym_comment, + ACTIONS(960), 2, + anon_sym_end, + anon_sym_elseif, + [23610] = 6, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(856), 1, + sym_vararg_expression, + ACTIONS(917), 1, + sym_identifier, + STATE(410), 1, + sym_comment, + STATE(456), 1, + sym__vararg_parameter, + [23629] = 5, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(964), 1, + sym_identifier, + ACTIONS(966), 1, + anon_sym_RPAREN, + STATE(411), 1, + sym_comment, + [23645] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(968), 1, + sym__block_string_content, + STATE(412), 1, + sym_comment, + [23658] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(970), 1, + anon_sym_do, + STATE(413), 1, + sym_comment, + [23671] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(972), 1, + anon_sym_until, + STATE(414), 1, + sym_comment, + [23684] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(974), 1, + anon_sym_do, + STATE(415), 1, + sym_comment, + [23697] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(976), 1, + sym_identifier, + STATE(416), 1, + sym_comment, + [23710] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(978), 1, + anon_sym_LPAREN, + STATE(417), 1, + sym_comment, + [23723] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(980), 1, + sym_identifier, + STATE(418), 1, + sym_comment, + [23736] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(982), 1, + sym__block_string_end, + STATE(419), 1, + sym_comment, + [23749] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(984), 1, + anon_sym_COLON_COLON, + STATE(420), 1, + sym_comment, + [23762] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(986), 1, + sym_identifier, + STATE(421), 1, + sym_comment, + [23775] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(988), 1, + anon_sym_RBRACE, + STATE(422), 1, + sym_comment, + [23788] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(990), 1, + sym_identifier, + STATE(423), 1, + sym_comment, + [23801] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(992), 1, + sym_identifier, + STATE(424), 1, + sym_comment, + [23814] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(994), 1, + anon_sym_end, + STATE(425), 1, + sym_comment, + [23827] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(361), 1, + ts_builtin_sym_end, + STATE(426), 1, + sym_comment, + [23840] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(996), 1, + anon_sym_end, + STATE(427), 1, + sym_comment, + [23853] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(998), 1, + sym_identifier, + STATE(428), 1, + sym_comment, + [23866] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1000), 1, + anon_sym_GT, + STATE(429), 1, + sym_comment, + [23879] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1002), 1, + sym_identifier, + STATE(430), 1, + sym_comment, + [23892] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1004), 1, + sym_identifier, + STATE(431), 1, + sym_comment, + [23905] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(359), 1, + ts_builtin_sym_end, + STATE(432), 1, + sym_comment, + [23918] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1006), 1, + anon_sym_end, + STATE(433), 1, + sym_comment, + [23931] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1008), 1, + anon_sym_end, + STATE(434), 1, + sym_comment, + [23944] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1010), 1, + anon_sym_EQ, + STATE(435), 1, + sym_comment, + [23957] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1012), 1, + anon_sym_end, + STATE(436), 1, + sym_comment, + [23970] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1014), 1, + sym__block_comment_content, + STATE(437), 1, + sym_comment, + [23983] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1016), 1, + anon_sym_end, + STATE(438), 1, + sym_comment, + [23996] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1018), 1, + anon_sym_end, + STATE(439), 1, + sym_comment, + [24009] = 4, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(862), 1, + anon_sym_DASH_DASH, + ACTIONS(1020), 1, + aux_sym_include_statement_token2, + STATE(440), 1, + sym_comment, + [24022] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1022), 1, + anon_sym_end, + STATE(441), 1, + sym_comment, + [24035] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1024), 1, + anon_sym_RPAREN, + STATE(442), 1, + sym_comment, + [24048] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1026), 1, + anon_sym_end, + STATE(443), 1, + sym_comment, + [24061] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1028), 1, + anon_sym_end, + STATE(444), 1, + sym_comment, + [24074] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1030), 1, + sym_identifier, + STATE(445), 1, + sym_comment, + [24087] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1032), 1, + anon_sym_in, + STATE(446), 1, + sym_comment, + [24100] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1034), 1, + anon_sym_LPAREN, + STATE(447), 1, + sym_comment, + [24113] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1036), 1, + sym__block_string_end, + STATE(448), 1, + sym_comment, + [24126] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1038), 1, + anon_sym_EQ, + STATE(449), 1, + sym_comment, + [24139] = 4, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(862), 1, + anon_sym_DASH_DASH, + ACTIONS(1040), 1, + aux_sym_include_statement_token2, + STATE(450), 1, + sym_comment, + [24152] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1042), 1, + anon_sym_RBRACE, + STATE(451), 1, + sym_comment, + [24165] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1044), 1, + anon_sym_RBRACE, + STATE(452), 1, + sym_comment, + [24178] = 4, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(862), 1, + anon_sym_DASH_DASH, + ACTIONS(1046), 1, + aux_sym_comment_token1, + STATE(453), 1, + sym_comment, + [24191] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1048), 1, + anon_sym_end, + STATE(454), 1, + sym_comment, + [24204] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1050), 1, + sym__block_string_end, + STATE(455), 1, + sym_comment, + [24217] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1052), 1, + anon_sym_RPAREN, + STATE(456), 1, + sym_comment, + [24230] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1054), 1, + anon_sym_RPAREN, + STATE(457), 1, + sym_comment, + [24243] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1056), 1, + anon_sym_RBRACE, + STATE(458), 1, + sym_comment, + [24256] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1058), 1, + sym_identifier, + STATE(459), 1, + sym_comment, + [24269] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1060), 1, + anon_sym_RPAREN, + STATE(460), 1, + sym_comment, + [24282] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1062), 1, + anon_sym_end, + STATE(461), 1, + sym_comment, + [24295] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1064), 1, + sym__block_string_content, + STATE(462), 1, + sym_comment, + [24308] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1066), 1, + ts_builtin_sym_end, + STATE(463), 1, + sym_comment, + [24321] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1068), 1, + sym__block_string_end, + STATE(464), 1, + sym_comment, + [24334] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1070), 1, + ts_builtin_sym_end, + STATE(465), 1, + sym_comment, + [24347] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1072), 1, + sym__block_string_content, + STATE(466), 1, + sym_comment, + [24360] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1074), 1, + anon_sym_do, + STATE(467), 1, + sym_comment, + [24373] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1076), 1, + sym_identifier, + STATE(468), 1, + sym_comment, + [24386] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1078), 1, + sym_identifier, + STATE(469), 1, + sym_comment, + [24399] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1080), 1, + sym_identifier, + STATE(470), 1, + sym_comment, + [24412] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1082), 1, + anon_sym_EQ, + STATE(471), 1, + sym_comment, + [24425] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1084), 1, + sym_identifier, + STATE(472), 1, + sym_comment, + [24438] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1086), 1, + sym__block_string_content, + STATE(473), 1, + sym_comment, + [24451] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(917), 1, + sym_identifier, + STATE(474), 1, + sym_comment, + [24464] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1088), 1, + anon_sym_RPAREN, + STATE(475), 1, + sym_comment, + [24477] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1090), 1, + anon_sym_end, + STATE(476), 1, + sym_comment, + [24490] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1092), 1, + anon_sym_end, + STATE(477), 1, + sym_comment, + [24503] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1094), 1, + anon_sym_COLON_COLON, + STATE(478), 1, + sym_comment, + [24516] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1096), 1, + anon_sym_until, + STATE(479), 1, + sym_comment, + [24529] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1098), 1, + anon_sym_end, + STATE(480), 1, + sym_comment, + [24542] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1100), 1, + sym_identifier, + STATE(481), 1, + sym_comment, + [24555] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1102), 1, + anon_sym_GT, + STATE(482), 1, + sym_comment, + [24568] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1104), 1, + sym_identifier, + STATE(483), 1, + sym_comment, + [24581] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1106), 1, + anon_sym_end, + STATE(484), 1, + sym_comment, + [24594] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1108), 1, + anon_sym_end, + STATE(485), 1, + sym_comment, + [24607] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1110), 1, + sym_identifier, + STATE(486), 1, + sym_comment, + [24620] = 4, + ACTIONS(3), 1, + anon_sym_DASH_DASH, + ACTIONS(5), 1, + sym__block_comment_start, + ACTIONS(1112), 1, + sym__block_comment_end, + STATE(487), 1, + sym_comment, + [24633] = 1, + ACTIONS(1114), 1, + ts_builtin_sym_end, + [24637] = 1, + ACTIONS(1116), 1, + ts_builtin_sym_end, +}; + +static const uint32_t ts_small_parse_table_map[] = { + [SMALL_STATE(11)] = 0, + [SMALL_STATE(12)] = 74, + [SMALL_STATE(13)] = 148, + [SMALL_STATE(14)] = 222, + [SMALL_STATE(15)] = 300, + [SMALL_STATE(16)] = 374, + [SMALL_STATE(17)] = 448, + [SMALL_STATE(18)] = 522, + [SMALL_STATE(19)] = 596, + [SMALL_STATE(20)] = 670, + [SMALL_STATE(21)] = 744, + [SMALL_STATE(22)] = 818, + [SMALL_STATE(23)] = 892, + [SMALL_STATE(24)] = 966, + [SMALL_STATE(25)] = 1040, + [SMALL_STATE(26)] = 1109, + [SMALL_STATE(27)] = 1178, + [SMALL_STATE(28)] = 1247, + [SMALL_STATE(29)] = 1320, + [SMALL_STATE(30)] = 1389, + [SMALL_STATE(31)] = 1458, + [SMALL_STATE(32)] = 1527, + [SMALL_STATE(33)] = 1596, + [SMALL_STATE(34)] = 1665, + [SMALL_STATE(35)] = 1734, + [SMALL_STATE(36)] = 1803, + [SMALL_STATE(37)] = 1872, + [SMALL_STATE(38)] = 1941, + [SMALL_STATE(39)] = 2010, + [SMALL_STATE(40)] = 2079, + [SMALL_STATE(41)] = 2148, + [SMALL_STATE(42)] = 2217, + [SMALL_STATE(43)] = 2302, + [SMALL_STATE(44)] = 2385, + [SMALL_STATE(45)] = 2454, + [SMALL_STATE(46)] = 2521, + [SMALL_STATE(47)] = 2594, + [SMALL_STATE(48)] = 2673, + [SMALL_STATE(49)] = 2742, + [SMALL_STATE(50)] = 2809, + [SMALL_STATE(51)] = 2876, + [SMALL_STATE(52)] = 2943, + [SMALL_STATE(53)] = 3010, + [SMALL_STATE(54)] = 3077, + [SMALL_STATE(55)] = 3144, + [SMALL_STATE(56)] = 3235, + [SMALL_STATE(57)] = 3332, + [SMALL_STATE(58)] = 3399, + [SMALL_STATE(59)] = 3466, + [SMALL_STATE(60)] = 3533, + [SMALL_STATE(61)] = 3600, + [SMALL_STATE(62)] = 3669, + [SMALL_STATE(63)] = 3764, + [SMALL_STATE(64)] = 3843, + [SMALL_STATE(65)] = 3932, + [SMALL_STATE(66)] = 4070, + [SMALL_STATE(67)] = 4208, + [SMALL_STATE(68)] = 4308, + [SMALL_STATE(69)] = 4408, + [SMALL_STATE(70)] = 4507, + [SMALL_STATE(71)] = 4606, + [SMALL_STATE(72)] = 4701, + [SMALL_STATE(73)] = 4796, + [SMALL_STATE(74)] = 4921, + [SMALL_STATE(75)] = 5043, + [SMALL_STATE(76)] = 5137, + [SMALL_STATE(77)] = 5199, + [SMALL_STATE(78)] = 5263, + [SMALL_STATE(79)] = 5357, + [SMALL_STATE(80)] = 5451, + [SMALL_STATE(81)] = 5513, + [SMALL_STATE(82)] = 5599, + [SMALL_STATE(83)] = 5691, + [SMALL_STATE(84)] = 5781, + [SMALL_STATE(85)] = 5865, + [SMALL_STATE(86)] = 5945, + [SMALL_STATE(87)] = 6023, + [SMALL_STATE(88)] = 6097, + [SMALL_STATE(89)] = 6165, + [SMALL_STATE(90)] = 6229, + [SMALL_STATE(91)] = 6303, + [SMALL_STATE(92)] = 6367, + [SMALL_STATE(93)] = 6461, + [SMALL_STATE(94)] = 6523, + [SMALL_STATE(95)] = 6617, + [SMALL_STATE(96)] = 6679, + [SMALL_STATE(97)] = 6741, + [SMALL_STATE(98)] = 6803, + [SMALL_STATE(99)] = 6865, + [SMALL_STATE(100)] = 6927, + [SMALL_STATE(101)] = 6989, + [SMALL_STATE(102)] = 7051, + [SMALL_STATE(103)] = 7113, + [SMALL_STATE(104)] = 7206, + [SMALL_STATE(105)] = 7329, + [SMALL_STATE(106)] = 7452, + [SMALL_STATE(107)] = 7545, + [SMALL_STATE(108)] = 7668, + [SMALL_STATE(109)] = 7761, + [SMALL_STATE(110)] = 7884, + [SMALL_STATE(111)] = 8001, + [SMALL_STATE(112)] = 8122, + [SMALL_STATE(113)] = 8245, + [SMALL_STATE(114)] = 8368, + [SMALL_STATE(115)] = 8491, + [SMALL_STATE(116)] = 8614, + [SMALL_STATE(117)] = 8737, + [SMALL_STATE(118)] = 8860, + [SMALL_STATE(119)] = 8983, + [SMALL_STATE(120)] = 9098, + [SMALL_STATE(121)] = 9218, + [SMALL_STATE(122)] = 9338, + [SMALL_STATE(123)] = 9458, + [SMALL_STATE(124)] = 9566, + [SMALL_STATE(125)] = 9674, + [SMALL_STATE(126)] = 9782, + [SMALL_STATE(127)] = 9879, + [SMALL_STATE(128)] = 9934, + [SMALL_STATE(129)] = 10028, + [SMALL_STATE(130)] = 10122, + [SMALL_STATE(131)] = 10216, + [SMALL_STATE(132)] = 10310, + [SMALL_STATE(133)] = 10401, + [SMALL_STATE(134)] = 10492, + [SMALL_STATE(135)] = 10578, + [SMALL_STATE(136)] = 10666, + [SMALL_STATE(137)] = 10748, + [SMALL_STATE(138)] = 10833, + [SMALL_STATE(139)] = 10918, + [SMALL_STATE(140)] = 11003, + [SMALL_STATE(141)] = 11088, + [SMALL_STATE(142)] = 11173, + [SMALL_STATE(143)] = 11258, + [SMALL_STATE(144)] = 11343, + [SMALL_STATE(145)] = 11425, + [SMALL_STATE(146)] = 11507, + [SMALL_STATE(147)] = 11589, + [SMALL_STATE(148)] = 11671, + [SMALL_STATE(149)] = 11753, + [SMALL_STATE(150)] = 11835, + [SMALL_STATE(151)] = 11917, + [SMALL_STATE(152)] = 11999, + [SMALL_STATE(153)] = 12081, + [SMALL_STATE(154)] = 12163, + [SMALL_STATE(155)] = 12245, + [SMALL_STATE(156)] = 12327, + [SMALL_STATE(157)] = 12409, + [SMALL_STATE(158)] = 12491, + [SMALL_STATE(159)] = 12573, + [SMALL_STATE(160)] = 12655, + [SMALL_STATE(161)] = 12737, + [SMALL_STATE(162)] = 12819, + [SMALL_STATE(163)] = 12901, + [SMALL_STATE(164)] = 12983, + [SMALL_STATE(165)] = 13065, + [SMALL_STATE(166)] = 13147, + [SMALL_STATE(167)] = 13229, + [SMALL_STATE(168)] = 13311, + [SMALL_STATE(169)] = 13393, + [SMALL_STATE(170)] = 13475, + [SMALL_STATE(171)] = 13557, + [SMALL_STATE(172)] = 13639, + [SMALL_STATE(173)] = 13721, + [SMALL_STATE(174)] = 13803, + [SMALL_STATE(175)] = 13885, + [SMALL_STATE(176)] = 13967, + [SMALL_STATE(177)] = 14049, + [SMALL_STATE(178)] = 14131, + [SMALL_STATE(179)] = 14213, + [SMALL_STATE(180)] = 14295, + [SMALL_STATE(181)] = 14377, + [SMALL_STATE(182)] = 14459, + [SMALL_STATE(183)] = 14541, + [SMALL_STATE(184)] = 14623, + [SMALL_STATE(185)] = 14705, + [SMALL_STATE(186)] = 14787, + [SMALL_STATE(187)] = 14869, + [SMALL_STATE(188)] = 14951, + [SMALL_STATE(189)] = 15033, + [SMALL_STATE(190)] = 15115, + [SMALL_STATE(191)] = 15197, + [SMALL_STATE(192)] = 15279, + [SMALL_STATE(193)] = 15361, + [SMALL_STATE(194)] = 15443, + [SMALL_STATE(195)] = 15525, + [SMALL_STATE(196)] = 15607, + [SMALL_STATE(197)] = 15689, + [SMALL_STATE(198)] = 15771, + [SMALL_STATE(199)] = 15853, + [SMALL_STATE(200)] = 15935, + [SMALL_STATE(201)] = 16017, + [SMALL_STATE(202)] = 16099, + [SMALL_STATE(203)] = 16181, + [SMALL_STATE(204)] = 16263, + [SMALL_STATE(205)] = 16337, + [SMALL_STATE(206)] = 16411, + [SMALL_STATE(207)] = 16489, + [SMALL_STATE(208)] = 16567, + [SMALL_STATE(209)] = 16641, + [SMALL_STATE(210)] = 16716, + [SMALL_STATE(211)] = 16788, + [SMALL_STATE(212)] = 16860, + [SMALL_STATE(213)] = 16932, + [SMALL_STATE(214)] = 17004, + [SMALL_STATE(215)] = 17076, + [SMALL_STATE(216)] = 17148, + [SMALL_STATE(217)] = 17220, + [SMALL_STATE(218)] = 17292, + [SMALL_STATE(219)] = 17364, + [SMALL_STATE(220)] = 17436, + [SMALL_STATE(221)] = 17508, + [SMALL_STATE(222)] = 17580, + [SMALL_STATE(223)] = 17652, + [SMALL_STATE(224)] = 17724, + [SMALL_STATE(225)] = 17796, + [SMALL_STATE(226)] = 17868, + [SMALL_STATE(227)] = 17940, + [SMALL_STATE(228)] = 17986, + [SMALL_STATE(229)] = 18058, + [SMALL_STATE(230)] = 18107, + [SMALL_STATE(231)] = 18156, + [SMALL_STATE(232)] = 18201, + [SMALL_STATE(233)] = 18249, + [SMALL_STATE(234)] = 18297, + [SMALL_STATE(235)] = 18340, + [SMALL_STATE(236)] = 18387, + [SMALL_STATE(237)] = 18434, + [SMALL_STATE(238)] = 18474, + [SMALL_STATE(239)] = 18516, + [SMALL_STATE(240)] = 18558, + [SMALL_STATE(241)] = 18600, + [SMALL_STATE(242)] = 18642, + [SMALL_STATE(243)] = 18684, + [SMALL_STATE(244)] = 18726, + [SMALL_STATE(245)] = 18768, + [SMALL_STATE(246)] = 18807, + [SMALL_STATE(247)] = 18846, + [SMALL_STATE(248)] = 18887, + [SMALL_STATE(249)] = 18928, + [SMALL_STATE(250)] = 18969, + [SMALL_STATE(251)] = 19010, + [SMALL_STATE(252)] = 19051, + [SMALL_STATE(253)] = 19090, + [SMALL_STATE(254)] = 19131, + [SMALL_STATE(255)] = 19168, + [SMALL_STATE(256)] = 19205, + [SMALL_STATE(257)] = 19246, + [SMALL_STATE(258)] = 19287, + [SMALL_STATE(259)] = 19323, + [SMALL_STATE(260)] = 19361, + [SMALL_STATE(261)] = 19401, + [SMALL_STATE(262)] = 19439, + [SMALL_STATE(263)] = 19477, + [SMALL_STATE(264)] = 19517, + [SMALL_STATE(265)] = 19553, + [SMALL_STATE(266)] = 19588, + [SMALL_STATE(267)] = 19623, + [SMALL_STATE(268)] = 19658, + [SMALL_STATE(269)] = 19693, + [SMALL_STATE(270)] = 19730, + [SMALL_STATE(271)] = 19765, + [SMALL_STATE(272)] = 19800, + [SMALL_STATE(273)] = 19835, + [SMALL_STATE(274)] = 19870, + [SMALL_STATE(275)] = 19905, + [SMALL_STATE(276)] = 19940, + [SMALL_STATE(277)] = 19975, + [SMALL_STATE(278)] = 20010, + [SMALL_STATE(279)] = 20045, + [SMALL_STATE(280)] = 20080, + [SMALL_STATE(281)] = 20115, + [SMALL_STATE(282)] = 20150, + [SMALL_STATE(283)] = 20185, + [SMALL_STATE(284)] = 20220, + [SMALL_STATE(285)] = 20255, + [SMALL_STATE(286)] = 20290, + [SMALL_STATE(287)] = 20325, + [SMALL_STATE(288)] = 20360, + [SMALL_STATE(289)] = 20395, + [SMALL_STATE(290)] = 20430, + [SMALL_STATE(291)] = 20465, + [SMALL_STATE(292)] = 20500, + [SMALL_STATE(293)] = 20535, + [SMALL_STATE(294)] = 20570, + [SMALL_STATE(295)] = 20605, + [SMALL_STATE(296)] = 20640, + [SMALL_STATE(297)] = 20675, + [SMALL_STATE(298)] = 20710, + [SMALL_STATE(299)] = 20744, + [SMALL_STATE(300)] = 20778, + [SMALL_STATE(301)] = 20812, + [SMALL_STATE(302)] = 20846, + [SMALL_STATE(303)] = 20880, + [SMALL_STATE(304)] = 20914, + [SMALL_STATE(305)] = 20948, + [SMALL_STATE(306)] = 20982, + [SMALL_STATE(307)] = 21016, + [SMALL_STATE(308)] = 21050, + [SMALL_STATE(309)] = 21084, + [SMALL_STATE(310)] = 21118, + [SMALL_STATE(311)] = 21152, + [SMALL_STATE(312)] = 21186, + [SMALL_STATE(313)] = 21220, + [SMALL_STATE(314)] = 21254, + [SMALL_STATE(315)] = 21288, + [SMALL_STATE(316)] = 21322, + [SMALL_STATE(317)] = 21356, + [SMALL_STATE(318)] = 21390, + [SMALL_STATE(319)] = 21424, + [SMALL_STATE(320)] = 21458, + [SMALL_STATE(321)] = 21494, + [SMALL_STATE(322)] = 21530, + [SMALL_STATE(323)] = 21564, + [SMALL_STATE(324)] = 21598, + [SMALL_STATE(325)] = 21632, + [SMALL_STATE(326)] = 21666, + [SMALL_STATE(327)] = 21700, + [SMALL_STATE(328)] = 21734, + [SMALL_STATE(329)] = 21768, + [SMALL_STATE(330)] = 21802, + [SMALL_STATE(331)] = 21837, + [SMALL_STATE(332)] = 21868, + [SMALL_STATE(333)] = 21899, + [SMALL_STATE(334)] = 21946, + [SMALL_STATE(335)] = 21993, + [SMALL_STATE(336)] = 22040, + [SMALL_STATE(337)] = 22078, + [SMALL_STATE(338)] = 22104, + [SMALL_STATE(339)] = 22128, + [SMALL_STATE(340)] = 22166, + [SMALL_STATE(341)] = 22199, + [SMALL_STATE(342)] = 22226, + [SMALL_STATE(343)] = 22246, + [SMALL_STATE(344)] = 22274, + [SMALL_STATE(345)] = 22302, + [SMALL_STATE(346)] = 22324, + [SMALL_STATE(347)] = 22352, + [SMALL_STATE(348)] = 22380, + [SMALL_STATE(349)] = 22408, + [SMALL_STATE(350)] = 22436, + [SMALL_STATE(351)] = 22464, + [SMALL_STATE(352)] = 22492, + [SMALL_STATE(353)] = 22511, + [SMALL_STATE(354)] = 22534, + [SMALL_STATE(355)] = 22553, + [SMALL_STATE(356)] = 22570, + [SMALL_STATE(357)] = 22595, + [SMALL_STATE(358)] = 22618, + [SMALL_STATE(359)] = 22639, + [SMALL_STATE(360)] = 22662, + [SMALL_STATE(361)] = 22687, + [SMALL_STATE(362)] = 22712, + [SMALL_STATE(363)] = 22732, + [SMALL_STATE(364)] = 22752, + [SMALL_STATE(365)] = 22774, + [SMALL_STATE(366)] = 22794, + [SMALL_STATE(367)] = 22812, + [SMALL_STATE(368)] = 22832, + [SMALL_STATE(369)] = 22850, + [SMALL_STATE(370)] = 22868, + [SMALL_STATE(371)] = 22888, + [SMALL_STATE(372)] = 22908, + [SMALL_STATE(373)] = 22928, + [SMALL_STATE(374)] = 22948, + [SMALL_STATE(375)] = 22968, + [SMALL_STATE(376)] = 22988, + [SMALL_STATE(377)] = 23008, + [SMALL_STATE(378)] = 23028, + [SMALL_STATE(379)] = 23048, + [SMALL_STATE(380)] = 23068, + [SMALL_STATE(381)] = 23088, + [SMALL_STATE(382)] = 23106, + [SMALL_STATE(383)] = 23124, + [SMALL_STATE(384)] = 23144, + [SMALL_STATE(385)] = 23164, + [SMALL_STATE(386)] = 23184, + [SMALL_STATE(387)] = 23203, + [SMALL_STATE(388)] = 23220, + [SMALL_STATE(389)] = 23239, + [SMALL_STATE(390)] = 23258, + [SMALL_STATE(391)] = 23277, + [SMALL_STATE(392)] = 23292, + [SMALL_STATE(393)] = 23307, + [SMALL_STATE(394)] = 23322, + [SMALL_STATE(395)] = 23341, + [SMALL_STATE(396)] = 23356, + [SMALL_STATE(397)] = 23373, + [SMALL_STATE(398)] = 23392, + [SMALL_STATE(399)] = 23411, + [SMALL_STATE(400)] = 23430, + [SMALL_STATE(401)] = 23449, + [SMALL_STATE(402)] = 23468, + [SMALL_STATE(403)] = 23487, + [SMALL_STATE(404)] = 23502, + [SMALL_STATE(405)] = 23521, + [SMALL_STATE(406)] = 23538, + [SMALL_STATE(407)] = 23557, + [SMALL_STATE(408)] = 23576, + [SMALL_STATE(409)] = 23593, + [SMALL_STATE(410)] = 23610, + [SMALL_STATE(411)] = 23629, + [SMALL_STATE(412)] = 23645, + [SMALL_STATE(413)] = 23658, + [SMALL_STATE(414)] = 23671, + [SMALL_STATE(415)] = 23684, + [SMALL_STATE(416)] = 23697, + [SMALL_STATE(417)] = 23710, + [SMALL_STATE(418)] = 23723, + [SMALL_STATE(419)] = 23736, + [SMALL_STATE(420)] = 23749, + [SMALL_STATE(421)] = 23762, + [SMALL_STATE(422)] = 23775, + [SMALL_STATE(423)] = 23788, + [SMALL_STATE(424)] = 23801, + [SMALL_STATE(425)] = 23814, + [SMALL_STATE(426)] = 23827, + [SMALL_STATE(427)] = 23840, + [SMALL_STATE(428)] = 23853, + [SMALL_STATE(429)] = 23866, + [SMALL_STATE(430)] = 23879, + [SMALL_STATE(431)] = 23892, + [SMALL_STATE(432)] = 23905, + [SMALL_STATE(433)] = 23918, + [SMALL_STATE(434)] = 23931, + [SMALL_STATE(435)] = 23944, + [SMALL_STATE(436)] = 23957, + [SMALL_STATE(437)] = 23970, + [SMALL_STATE(438)] = 23983, + [SMALL_STATE(439)] = 23996, + [SMALL_STATE(440)] = 24009, + [SMALL_STATE(441)] = 24022, + [SMALL_STATE(442)] = 24035, + [SMALL_STATE(443)] = 24048, + [SMALL_STATE(444)] = 24061, + [SMALL_STATE(445)] = 24074, + [SMALL_STATE(446)] = 24087, + [SMALL_STATE(447)] = 24100, + [SMALL_STATE(448)] = 24113, + [SMALL_STATE(449)] = 24126, + [SMALL_STATE(450)] = 24139, + [SMALL_STATE(451)] = 24152, + [SMALL_STATE(452)] = 24165, + [SMALL_STATE(453)] = 24178, + [SMALL_STATE(454)] = 24191, + [SMALL_STATE(455)] = 24204, + [SMALL_STATE(456)] = 24217, + [SMALL_STATE(457)] = 24230, + [SMALL_STATE(458)] = 24243, + [SMALL_STATE(459)] = 24256, + [SMALL_STATE(460)] = 24269, + [SMALL_STATE(461)] = 24282, + [SMALL_STATE(462)] = 24295, + [SMALL_STATE(463)] = 24308, + [SMALL_STATE(464)] = 24321, + [SMALL_STATE(465)] = 24334, + [SMALL_STATE(466)] = 24347, + [SMALL_STATE(467)] = 24360, + [SMALL_STATE(468)] = 24373, + [SMALL_STATE(469)] = 24386, + [SMALL_STATE(470)] = 24399, + [SMALL_STATE(471)] = 24412, + [SMALL_STATE(472)] = 24425, + [SMALL_STATE(473)] = 24438, + [SMALL_STATE(474)] = 24451, + [SMALL_STATE(475)] = 24464, + [SMALL_STATE(476)] = 24477, + [SMALL_STATE(477)] = 24490, + [SMALL_STATE(478)] = 24503, + [SMALL_STATE(479)] = 24516, + [SMALL_STATE(480)] = 24529, + [SMALL_STATE(481)] = 24542, + [SMALL_STATE(482)] = 24555, + [SMALL_STATE(483)] = 24568, + [SMALL_STATE(484)] = 24581, + [SMALL_STATE(485)] = 24594, + [SMALL_STATE(486)] = 24607, + [SMALL_STATE(487)] = 24620, + [SMALL_STATE(488)] = 24633, + [SMALL_STATE(489)] = 24637, +}; + +static const TSParseActionEntry ts_parse_actions[] = { + [0] = {.entry = {.count = 0, .reusable = false}}, + [1] = {.entry = {.count = 1, .reusable = false}}, RECOVER(), + [3] = {.entry = {.count = 1, .reusable = true}}, SHIFT(453), + [5] = {.entry = {.count = 1, .reusable = true}}, SHIFT(437), + [7] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_chunk, 0, 0, 0), + [9] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2), + [11] = {.entry = {.count = 1, .reusable = true}}, SHIFT(122), + [13] = {.entry = {.count = 1, .reusable = false}}, SHIFT(126), + [15] = {.entry = {.count = 1, .reusable = true}}, SHIFT(272), + [17] = {.entry = {.count = 1, .reusable = true}}, SHIFT(431), + [19] = {.entry = {.count = 1, .reusable = false}}, SHIFT(275), + [21] = {.entry = {.count = 1, .reusable = false}}, SHIFT(486), + [23] = {.entry = {.count = 1, .reusable = false}}, SHIFT(105), + [25] = {.entry = {.count = 1, .reusable = false}}, SHIFT(197), + [27] = {.entry = {.count = 1, .reusable = true}}, SHIFT(181), + [29] = {.entry = {.count = 1, .reusable = false}}, SHIFT(117), + [31] = {.entry = {.count = 1, .reusable = false}}, SHIFT(147), + [33] = {.entry = {.count = 1, .reusable = false}}, SHIFT(370), + [35] = {.entry = {.count = 1, .reusable = false}}, SHIFT(356), + [37] = {.entry = {.count = 1, .reusable = false}}, SHIFT(343), + [39] = {.entry = {.count = 1, .reusable = true}}, SHIFT(148), + [41] = {.entry = {.count = 1, .reusable = true}}, SHIFT(450), + [43] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variable, 1, 0, 0), + [45] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_variable, 1, 0, 0), + [47] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_dot_index_expression, 3, 0, 28), + [49] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_dot_index_expression, 3, 0, 28), + [51] = {.entry = {.count = 1, .reusable = true}}, SHIFT(326), + [53] = {.entry = {.count = 1, .reusable = true}}, SHIFT(459), + [55] = {.entry = {.count = 1, .reusable = false}}, SHIFT(304), + [57] = {.entry = {.count = 1, .reusable = false}}, SHIFT(428), + [59] = {.entry = {.count = 1, .reusable = false}}, SHIFT(113), + [61] = {.entry = {.count = 1, .reusable = false}}, SHIFT(195), + [63] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_parenthesized_expression, 3, 0, 0), SHIFT(181), + [66] = {.entry = {.count = 1, .reusable = false}}, SHIFT(114), + [68] = {.entry = {.count = 1, .reusable = false}}, SHIFT(199), + [70] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_parenthesized_expression, 3, 0, 0), + [72] = {.entry = {.count = 1, .reusable = false}}, SHIFT(384), + [74] = {.entry = {.count = 1, .reusable = false}}, SHIFT(360), + [76] = {.entry = {.count = 1, .reusable = false}}, SHIFT(347), + [78] = {.entry = {.count = 1, .reusable = true}}, SHIFT(186), + [80] = {.entry = {.count = 1, .reusable = true}}, SHIFT(440), + [82] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parenthesized_expression, 3, 0, 0), + [84] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bracket_index_expression, 4, 0, 28), + [86] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bracket_index_expression, 4, 0, 28), + [88] = {.entry = {.count = 1, .reusable = false}}, SHIFT(202), + [90] = {.entry = {.count = 1, .reusable = false}}, SHIFT(196), + [92] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_parenthesized_expression, 3, 0, 0), SHIFT(105), + [95] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_parenthesized_expression, 3, 0, 0), SHIFT(113), + [98] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_call, 2, 0, 13), + [100] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_call, 2, 0, 13), + [102] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_arguments, 1, 0, 0), + [104] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_arguments, 1, 0, 0), + [106] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_arguments, 2, 0, 0), + [108] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_arguments, 2, 0, 0), + [110] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression, 1, 0, 0), + [112] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression, 1, 0, 0), + [114] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__prefix_expression, 1, 0, 0), + [116] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__prefix_expression, 1, 0, 0), + [118] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_arguments, 3, 0, 0), + [120] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_arguments, 3, 0, 0), + [122] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__quote_string, 2, 0, 17), + [124] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__quote_string, 2, 0, 17), + [126] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_string, 3, 0, 15), + [128] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block_string, 3, 0, 15), + [130] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__quote_string, 3, 0, 35), + [132] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__quote_string, 3, 0, 35), + [134] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_table_constructor, 3, 0, 0), + [136] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_table_constructor, 3, 0, 0), + [138] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_string, 1, 0, 6), + [140] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_string, 1, 0, 6), + [142] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_table_constructor, 2, 0, 0), + [144] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_table_constructor, 2, 0, 0), + [146] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_arguments, 4, 0, 0), + [148] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_arguments, 4, 0, 0), + [150] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binary_expression, 3, 0, 36), + [152] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binary_expression, 3, 0, 36), + [154] = {.entry = {.count = 1, .reusable = true}}, SHIFT(172), + [156] = {.entry = {.count = 1, .reusable = false}}, SHIFT(173), + [158] = {.entry = {.count = 1, .reusable = true}}, SHIFT(173), + [160] = {.entry = {.count = 1, .reusable = true}}, SHIFT(174), + [162] = {.entry = {.count = 1, .reusable = false}}, SHIFT(174), + [164] = {.entry = {.count = 1, .reusable = true}}, SHIFT(203), + [166] = {.entry = {.count = 1, .reusable = false}}, SHIFT(203), + [168] = {.entry = {.count = 1, .reusable = true}}, SHIFT(175), + [170] = {.entry = {.count = 1, .reusable = false}}, SHIFT(176), + [172] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_definition, 2, 0, 16), + [174] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_definition, 2, 0, 16), + [176] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_body, 2, 0, 34), + [178] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__function_body, 2, 0, 34), + [180] = {.entry = {.count = 1, .reusable = true}}, SHIFT(170), + [182] = {.entry = {.count = 1, .reusable = false}}, SHIFT(171), + [184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(171), + [186] = {.entry = {.count = 1, .reusable = false}}, SHIFT(167), + [188] = {.entry = {.count = 1, .reusable = false}}, SHIFT(169), + [190] = {.entry = {.count = 1, .reusable = true}}, SHIFT(167), + [192] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_body, 3, 0, 51), + [194] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__function_body, 3, 0, 51), + [196] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unary_expression, 2, 0, 19), + [198] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unary_expression, 2, 0, 19), + [200] = {.entry = {.count = 1, .reusable = false}}, SHIFT(277), + [202] = {.entry = {.count = 1, .reusable = false}}, SHIFT(177), + [204] = {.entry = {.count = 1, .reusable = false}}, SHIFT(109), + [206] = {.entry = {.count = 1, .reusable = false}}, SHIFT(300), + [208] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_print_shorthand_statement, 2, 0, 11), + [210] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_print_shorthand_statement, 2, 0, 11), + [212] = {.entry = {.count = 1, .reusable = true}}, SHIFT(194), + [214] = {.entry = {.count = 1, .reusable = false}}, SHIFT(168), + [216] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__variable_assignment_explist, 1, 0, 18), + [218] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__variable_assignment_explist, 1, 0, 18), + [220] = {.entry = {.count = 1, .reusable = true}}, SHIFT(179), + [222] = {.entry = {.count = 1, .reusable = true}}, SHIFT(163), + [224] = {.entry = {.count = 1, .reusable = false}}, SHIFT(150), + [226] = {.entry = {.count = 1, .reusable = false}}, SHIFT(151), + [228] = {.entry = {.count = 1, .reusable = false}}, SHIFT(152), + [230] = {.entry = {.count = 1, .reusable = true}}, SHIFT(150), + [232] = {.entry = {.count = 1, .reusable = true}}, SHIFT(153), + [234] = {.entry = {.count = 1, .reusable = false}}, SHIFT(154), + [236] = {.entry = {.count = 1, .reusable = true}}, SHIFT(154), + [238] = {.entry = {.count = 1, .reusable = true}}, SHIFT(155), + [240] = {.entry = {.count = 1, .reusable = false}}, SHIFT(144), + [242] = {.entry = {.count = 1, .reusable = true}}, SHIFT(144), + [244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(156), + [246] = {.entry = {.count = 1, .reusable = false}}, SHIFT(156), + [248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(157), + [250] = {.entry = {.count = 1, .reusable = false}}, SHIFT(157), + [252] = {.entry = {.count = 1, .reusable = true}}, SHIFT(158), + [254] = {.entry = {.count = 1, .reusable = false}}, SHIFT(159), + [256] = {.entry = {.count = 1, .reusable = true}}, SHIFT(178), + [258] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__variable_assignment_explist_repeat1, 2, 0, 63), + [260] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__variable_assignment_explist_repeat1, 2, 0, 63), + [262] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_print_shorthand_statement_repeat1, 2, 0, 47), + [264] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_print_shorthand_statement_repeat1, 2, 0, 47), + [266] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_elseif_statement, 3, 0, 37), + [268] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block, 1, 0, 0), + [270] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 3, 0, 21), + [272] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 3, 0, 21), + [274] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 4, 0, 38), + [276] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 4, 0, 38), + [278] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_compound_assignment_statement, 3, 0, 31), + [280] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_compound_assignment_statement, 3, 0, 31), + [282] = {.entry = {.count = 1, .reusable = false}}, SHIFT(278), + [284] = {.entry = {.count = 1, .reusable = false}}, SHIFT(283), + [286] = {.entry = {.count = 1, .reusable = false}}, SHIFT(52), + [288] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_else_statement, 1, 0, 0), + [290] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0), + [292] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0), SHIFT_REPEAT(2), + [295] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0), + [297] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0), SHIFT_REPEAT(272), + [300] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0), SHIFT_REPEAT(431), + [303] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0), SHIFT_REPEAT(275), + [306] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0), SHIFT_REPEAT(486), + [309] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0), SHIFT_REPEAT(105), + [312] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0), SHIFT_REPEAT(197), + [315] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0), SHIFT_REPEAT(181), + [318] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0), SHIFT_REPEAT(117), + [321] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0), SHIFT_REPEAT(147), + [324] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0), SHIFT_REPEAT(370), + [327] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0), SHIFT_REPEAT(356), + [330] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0), SHIFT_REPEAT(343), + [333] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0), SHIFT_REPEAT(148), + [336] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0), SHIFT_REPEAT(450), + [339] = {.entry = {.count = 1, .reusable = false}}, SHIFT(276), + [341] = {.entry = {.count = 1, .reusable = false}}, SHIFT(328), + [343] = {.entry = {.count = 1, .reusable = false}}, SHIFT(198), + [345] = {.entry = {.count = 1, .reusable = false}}, SHIFT(80), + [347] = {.entry = {.count = 1, .reusable = false}}, SHIFT(329), + [349] = {.entry = {.count = 1, .reusable = false}}, SHIFT(164), + [351] = {.entry = {.count = 1, .reusable = false}}, SHIFT(301), + [353] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0), SHIFT_REPEAT(202), + [356] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0), SHIFT_REPEAT(196), + [359] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_chunk, 1, 0, 0), + [361] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_chunk, 2, 0, 0), + [363] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_return_statement, 1, 0, 0), + [365] = {.entry = {.count = 1, .reusable = true}}, SHIFT(352), + [367] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_return_statement, 1, 0, 0), + [369] = {.entry = {.count = 1, .reusable = false}}, SHIFT(399), + [371] = {.entry = {.count = 1, .reusable = false}}, SHIFT(57), + [373] = {.entry = {.count = 1, .reusable = true}}, SHIFT(57), + [375] = {.entry = {.count = 1, .reusable = true}}, SHIFT(383), + [377] = {.entry = {.count = 1, .reusable = true}}, SHIFT(367), + [379] = {.entry = {.count = 1, .reusable = true}}, SHIFT(129), + [381] = {.entry = {.count = 1, .reusable = true}}, SHIFT(184), + [383] = {.entry = {.count = 1, .reusable = false}}, SHIFT(184), + [385] = {.entry = {.count = 1, .reusable = true}}, SHIFT(466), + [387] = {.entry = {.count = 1, .reusable = false}}, SHIFT(160), + [389] = {.entry = {.count = 1, .reusable = false}}, SHIFT(127), + [391] = {.entry = {.count = 1, .reusable = true}}, SHIFT(161), + [393] = {.entry = {.count = 1, .reusable = true}}, SHIFT(39), + [395] = {.entry = {.count = 1, .reusable = true}}, SHIFT(59), + [397] = {.entry = {.count = 1, .reusable = true}}, SHIFT(98), + [399] = {.entry = {.count = 1, .reusable = true}}, SHIFT(23), + [401] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__field_list, 3, 0, 0), + [403] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__field_list, 2, 0, 0), + [405] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__expression_list, 1, 0, 0), + [407] = {.entry = {.count = 1, .reusable = true}}, SHIFT(166), + [409] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__expression_list, 1, 0, 0), + [411] = {.entry = {.count = 1, .reusable = true}}, SHIFT(168), + [413] = {.entry = {.count = 1, .reusable = true}}, SHIFT(169), + [415] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__expression_list_repeat1, 2, 0, 0), + [417] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__expression_list_repeat1, 2, 0, 0), + [419] = {.entry = {.count = 1, .reusable = true}}, SHIFT(32), + [421] = {.entry = {.count = 1, .reusable = true}}, SHIFT(13), + [423] = {.entry = {.count = 1, .reusable = false}}, SHIFT(27), + [425] = {.entry = {.count = 1, .reusable = true}}, SHIFT(190), + [427] = {.entry = {.count = 1, .reusable = false}}, SHIFT(394), + [429] = {.entry = {.count = 1, .reusable = false}}, SHIFT(102), + [431] = {.entry = {.count = 1, .reusable = true}}, SHIFT(102), + [433] = {.entry = {.count = 1, .reusable = true}}, SHIFT(371), + [435] = {.entry = {.count = 1, .reusable = true}}, SHIFT(372), + [437] = {.entry = {.count = 1, .reusable = true}}, SHIFT(130), + [439] = {.entry = {.count = 1, .reusable = true}}, SHIFT(189), + [441] = {.entry = {.count = 1, .reusable = false}}, SHIFT(189), + [443] = {.entry = {.count = 1, .reusable = true}}, SHIFT(412), + [445] = {.entry = {.count = 1, .reusable = true}}, SHIFT(165), + [447] = {.entry = {.count = 1, .reusable = true}}, SHIFT(191), + [449] = {.entry = {.count = 1, .reusable = true}}, SHIFT(192), + [451] = {.entry = {.count = 1, .reusable = true}}, SHIFT(149), + [453] = {.entry = {.count = 1, .reusable = true}}, SHIFT(200), + [455] = {.entry = {.count = 1, .reusable = true}}, SHIFT(201), + [457] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field, 5, 0, 71), + [459] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field, 1, 0, 18), + [461] = {.entry = {.count = 1, .reusable = true}}, SHIFT(16), + [463] = {.entry = {.count = 1, .reusable = true}}, SHIFT(34), + [465] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field, 3, 0, 52), + [467] = {.entry = {.count = 1, .reusable = true}}, SHIFT(187), + [469] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_numeric_clause, 5, 0, 69), + [471] = {.entry = {.count = 1, .reusable = true}}, SHIFT(7), + [473] = {.entry = {.count = 1, .reusable = true}}, SHIFT(9), + [475] = {.entry = {.count = 1, .reusable = true}}, SHIFT(73), + [477] = {.entry = {.count = 1, .reusable = true}}, SHIFT(4), + [479] = {.entry = {.count = 1, .reusable = true}}, SHIFT(8), + [481] = {.entry = {.count = 1, .reusable = true}}, SHIFT(15), + [483] = {.entry = {.count = 1, .reusable = true}}, SHIFT(112), + [485] = {.entry = {.count = 1, .reusable = true}}, SHIFT(182), + [487] = {.entry = {.count = 1, .reusable = true}}, SHIFT(31), + [489] = {.entry = {.count = 1, .reusable = true}}, SHIFT(5), + [491] = {.entry = {.count = 1, .reusable = true}}, SHIFT(10), + [493] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_numeric_clause, 7, 0, 74), + [495] = {.entry = {.count = 1, .reusable = true}}, SHIFT(6), + [497] = {.entry = {.count = 1, .reusable = true}}, SHIFT(66), + [499] = {.entry = {.count = 1, .reusable = true}}, SHIFT(35), + [501] = {.entry = {.count = 1, .reusable = true}}, SHIFT(116), + [503] = {.entry = {.count = 1, .reusable = true}}, SHIFT(435), + [505] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_statement, 1, 0, 0), + [507] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_statement, 1, 0, 0), + [509] = {.entry = {.count = 1, .reusable = true}}, SHIFT(65), + [511] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__variable_assignment_varlist, 1, 0, 4), + [513] = {.entry = {.count = 1, .reusable = true}}, SHIFT(340), + [515] = {.entry = {.count = 1, .reusable = true}}, SHIFT(145), + [517] = {.entry = {.count = 1, .reusable = true}}, SHIFT(146), + [519] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__att_name_list, 1, 0, 4), + [521] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__att_name_list, 1, 0, 4), + [523] = {.entry = {.count = 1, .reusable = true}}, SHIFT(423), + [525] = {.entry = {.count = 1, .reusable = true}}, SHIFT(445), + [527] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__att_name_list, 2, 0, 25), + [529] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__att_name_list, 2, 0, 25), + [531] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__att_name_list_repeat1, 2, 0, 30), + [533] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__att_name_list_repeat1, 2, 0, 30), + [535] = {.entry = {.count = 1, .reusable = true}}, SHIFT(430), + [537] = {.entry = {.count = 1, .reusable = true}}, SHIFT(469), + [539] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__att_name_list_repeat1, 2, 0, 43), + [541] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__att_name_list_repeat1, 2, 0, 43), + [543] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__att_name_list_repeat1, 2, 0, 43), SHIFT_REPEAT(423), + [546] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__att_name_list, 3, 0, 42), + [548] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__att_name_list, 3, 0, 42), + [550] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__att_name_list, 2, 0, 23), + [552] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__att_name_list, 2, 0, 23), + [554] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__att_name_list, 2, 0, 24), + [556] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__att_name_list, 2, 0, 24), + [558] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__att_name_list, 3, 0, 46), + [560] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__att_name_list, 3, 0, 46), + [562] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__att_name_list, 4, 0, 62), + [564] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__att_name_list, 4, 0, 62), + [566] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__att_name_list, 3, 0, 45), + [568] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__att_name_list, 3, 0, 45), + [570] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__variable_assignment_explist_repeat1, 2, 0, 64), + [572] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__variable_assignment_explist_repeat1, 2, 0, 64), + [574] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__variable_assignment_explist_repeat1, 2, 0, 64), SHIFT_REPEAT(179), + [577] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__att_name_list_repeat1, 2, 0, 43), SHIFT_REPEAT(430), + [580] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__variable_assignment_explist, 2, 0, 49), + [582] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__variable_assignment_explist, 2, 0, 49), + [584] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_print_shorthand_statement_repeat1, 2, 0, 48), + [586] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_print_shorthand_statement_repeat1, 2, 0, 48), + [588] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_print_shorthand_statement_repeat1, 2, 0, 48), SHIFT_REPEAT(194), + [591] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_print_shorthand_statement, 3, 0, 26), + [593] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_print_shorthand_statement, 3, 0, 26), + [595] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__attrib, 3, 0, 0), + [597] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__attrib, 3, 0, 0), + [599] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__att_name_list_repeat1, 3, 0, 61), + [601] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__att_name_list_repeat1, 3, 0, 61), + [603] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variable_declaration, 2, 0, 10), + [605] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_variable_declaration, 2, 0, 10), + [607] = {.entry = {.count = 1, .reusable = true}}, SHIFT(142), + [609] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__variable_assignment_explist_repeat1, 2, 0, 64), SHIFT_REPEAT(178), + [612] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_print_shorthand_statement_repeat1, 2, 0, 48), SHIFT_REPEAT(163), + [615] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_statement, 5, 0, 57), + [617] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_statement, 5, 0, 57), + [619] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_shorthand_if_statement, 7, 0, 72), + [621] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_shorthand_if_statement, 7, 0, 72), + [623] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_statement, 7, 0, 73), + [625] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_statement, 7, 0, 73), + [627] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 3, 0, 22), + [629] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 3, 0, 22), + [631] = {.entry = {.count = 1, .reusable = true}}, SHIFT(140), + [633] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment_statement, 3, 0, 27), + [635] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment_statement, 3, 0, 27), + [637] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variable_declaration, 2, 0, 9), + [639] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_variable_declaration, 2, 0, 9), + [641] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_empty_statement, 1, 0, 0), + [643] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_empty_statement, 1, 0, 0), + [645] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_include_statement, 2, 0, 12), + [647] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_include_statement, 2, 0, 12), + [649] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__field_sep, 1, 0, 0), + [651] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__field_sep, 1, 0, 0), + [653] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_while_statement, 4, 0, 37), + [655] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_while_statement, 4, 0, 37), + [657] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_statement, 4, 0, 37), + [659] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_statement, 4, 0, 37), + [661] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 4, 0, 40), + [663] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 4, 0, 40), + [665] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_statement, 6, 0, 68), + [667] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_statement, 6, 0, 68), + [669] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__local_function_declaration, 4, 0, 41), + [671] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__local_function_declaration, 4, 0, 41), + [673] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__variable_assignment, 3, 0, 44), + [675] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__variable_assignment, 3, 0, 44), + [677] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_goto_statement, 2, 0, 0), + [679] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_goto_statement, 2, 0, 0), + [681] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_do_statement, 2, 0, 0), + [683] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_do_statement, 2, 0, 0), + [685] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_shorthand_while_statement, 5, 0, 53), + [687] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_shorthand_while_statement, 5, 0, 53), + [689] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_while_statement, 5, 0, 54), + [691] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_while_statement, 5, 0, 54), + [693] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_chunk_repeat1, 1, 0, 0), + [695] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_chunk_repeat1, 1, 0, 0), + [697] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_statement, 5, 0, 56), + [699] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_statement, 5, 0, 56), + [701] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_statement, 5, 0, 58), + [703] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_statement, 5, 0, 58), + [705] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 5, 0, 60), + [707] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 5, 0, 60), + [709] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_label_statement, 3, 0, 0), + [711] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_label_statement, 3, 0, 0), + [713] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_do_statement, 3, 0, 20), + [715] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_do_statement, 3, 0, 20), + [717] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_statement, 1, 0, 1), + [719] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_statement, 1, 0, 1), + [721] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_declaration, 1, 0, 0), + [723] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_declaration, 1, 0, 0), + [725] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_declaration, 1, 0, 2), + [727] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_declaration, 1, 0, 2), + [729] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_declaration, 1, 0, 3), + [731] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_declaration, 1, 0, 3), + [733] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_statement, 6, 0, 66), + [735] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_statement, 6, 0, 66), + [737] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_statement, 6, 0, 67), + [739] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_statement, 6, 0, 67), + [741] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_shorthand_if_statement, 5, 0, 55), + [743] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_shorthand_if_statement, 5, 0, 55), + [745] = {.entry = {.count = 1, .reusable = false}}, SHIFT(124), + [747] = {.entry = {.count = 1, .reusable = false}}, SHIFT(125), + [749] = {.entry = {.count = 1, .reusable = false}}, SHIFT(123), + [751] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_parameters, 2, 0, 0), + [753] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameters, 2, 0, 0), + [755] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_parameters, 3, 0, 50), + [757] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameters, 3, 0, 50), + [759] = {.entry = {.count = 1, .reusable = true}}, SHIFT(138), + [761] = {.entry = {.count = 1, .reusable = true}}, SHIFT(470), + [763] = {.entry = {.count = 1, .reusable = true}}, SHIFT(421), + [765] = {.entry = {.count = 1, .reusable = true}}, SHIFT(375), + [767] = {.entry = {.count = 1, .reusable = true}}, SHIFT(376), + [769] = {.entry = {.count = 1, .reusable = true}}, SHIFT(188), + [771] = {.entry = {.count = 1, .reusable = true}}, SHIFT(128), + [773] = {.entry = {.count = 1, .reusable = true}}, SHIFT(473), + [775] = {.entry = {.count = 1, .reusable = true}}, SHIFT(418), + [777] = {.entry = {.count = 1, .reusable = true}}, SHIFT(193), + [779] = {.entry = {.count = 1, .reusable = true}}, SHIFT(139), + [781] = {.entry = {.count = 1, .reusable = true}}, SHIFT(379), + [783] = {.entry = {.count = 1, .reusable = true}}, SHIFT(380), + [785] = {.entry = {.count = 1, .reusable = true}}, SHIFT(131), + [787] = {.entry = {.count = 1, .reusable = true}}, SHIFT(462), + [789] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__expression_list_repeat1, 2, 0, 0), SHIFT_REPEAT(166), + [792] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__variable_assignment_varlist_repeat1, 2, 0, 30), + [794] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2), + [796] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__expression_list, 2, 0, 0), + [798] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__expression_list, 2, 0, 0), + [800] = {.entry = {.count = 1, .reusable = false}}, SHIFT(232), + [802] = {.entry = {.count = 1, .reusable = false}}, SHIFT(424), + [804] = {.entry = {.count = 1, .reusable = true}}, SHIFT(288), + [806] = {.entry = {.count = 1, .reusable = true}}, SHIFT(177), + [808] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_return_statement, 2, 0, 0), + [810] = {.entry = {.count = 1, .reusable = true}}, SHIFT(354), + [812] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_return_statement, 2, 0, 0), + [814] = {.entry = {.count = 1, .reusable = true}}, SHIFT(287), + [816] = {.entry = {.count = 1, .reusable = false}}, SHIFT(236), + [818] = {.entry = {.count = 1, .reusable = false}}, SHIFT(468), + [820] = {.entry = {.count = 1, .reusable = true}}, SHIFT(307), + [822] = {.entry = {.count = 1, .reusable = true}}, SHIFT(309), + [824] = {.entry = {.count = 1, .reusable = true}}, SHIFT(297), + [826] = {.entry = {.count = 1, .reusable = true}}, SHIFT(313), + [828] = {.entry = {.count = 1, .reusable = true}}, SHIFT(274), + [830] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__field_list, 1, 0, 0), + [832] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_return_statement, 3, 0, 0), + [834] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_return_statement, 3, 0, 0), + [836] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_method_index_expression, 3, 0, 29), + [838] = {.entry = {.count = 1, .reusable = true}}, SHIFT(403), + [840] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__field_list_repeat1, 2, 0, 0), SHIFT_REPEAT(274), + [843] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__field_list_repeat1, 2, 0, 0), + [845] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_if_statement_repeat1, 2, 0, 59), + [847] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_if_statement_repeat1, 2, 0, 59), SHIFT_REPEAT(177), + [850] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_if_statement_repeat1, 2, 0, 59), + [852] = {.entry = {.count = 1, .reusable = true}}, SHIFT(400), + [854] = {.entry = {.count = 1, .reusable = true}}, SHIFT(331), + [856] = {.entry = {.count = 1, .reusable = true}}, SHIFT(411), + [858] = {.entry = {.count = 1, .reusable = false}}, SHIFT(19), + [860] = {.entry = {.count = 1, .reusable = true}}, SHIFT(387), + [862] = {.entry = {.count = 1, .reusable = false}}, SHIFT(453), + [864] = {.entry = {.count = 1, .reusable = false}}, SHIFT(53), + [866] = {.entry = {.count = 1, .reusable = true}}, SHIFT(408), + [868] = {.entry = {.count = 1, .reusable = true}}, SHIFT(183), + [870] = {.entry = {.count = 1, .reusable = true}}, SHIFT(474), + [872] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__name_list, 1, 0, 4), + [874] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__doublequote_string_content, 2, 0, 0), + [876] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__doublequote_string_content, 2, 0, 0), SHIFT_REPEAT(387), + [879] = {.entry = {.count = 1, .reusable = false}}, SHIFT(58), + [881] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__name_list_repeat1, 2, 0, 32), SHIFT_REPEAT(474), + [884] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__name_list_repeat1, 2, 0, 32), + [886] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__singlequote_string_content, 2, 0, 0), + [888] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__singlequote_string_content, 2, 0, 0), SHIFT_REPEAT(408), + [891] = {.entry = {.count = 1, .reusable = true}}, SHIFT(364), + [893] = {.entry = {.count = 1, .reusable = false}}, SHIFT(97), + [895] = {.entry = {.count = 1, .reusable = false}}, SHIFT(100), + [897] = {.entry = {.count = 1, .reusable = false}}, SHIFT(25), + [899] = {.entry = {.count = 1, .reusable = false}}, SHIFT(41), + [901] = {.entry = {.count = 1, .reusable = false}}, SHIFT(17), + [903] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block, 1, 0, 0), + [905] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block, 2, 0, 0), + [907] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block, 2, 0, 0), + [909] = {.entry = {.count = 1, .reusable = true}}, SHIFT(361), + [911] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__doublequote_string_content, 1, 0, 0), + [913] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__doublequote_string_content, 1, 0, 0), + [915] = {.entry = {.count = 1, .reusable = true}}, SHIFT(24), + [917] = {.entry = {.count = 1, .reusable = true}}, SHIFT(391), + [919] = {.entry = {.count = 1, .reusable = true}}, SHIFT(410), + [921] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__parameter_list, 2, 0, 14), + [923] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__name_list_repeat1, 2, 0, 30), + [925] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_name_prefix_expression, 1, 0, 7), + [927] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_name_dot_index_expression, 3, 0, 28), + [929] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__variable_assignment_varlist_repeat1, 2, 0, 32), + [931] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__variable_assignment_varlist_repeat1, 2, 0, 32), SHIFT_REPEAT(340), + [934] = {.entry = {.count = 1, .reusable = true}}, SHIFT(389), + [936] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__parameter_list, 1, 0, 4), + [938] = {.entry = {.count = 1, .reusable = true}}, SHIFT(36), + [940] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__variable_assignment_varlist, 2, 0, 14), + [942] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_name_prefix_expression, 1, 0, 0), + [944] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_if_statement_repeat1, 1, 0, 39), + [946] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_if_statement_repeat1, 1, 0, 39), + [948] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_name, 1, 0, 0), + [950] = {.entry = {.count = 1, .reusable = true}}, SHIFT(481), + [952] = {.entry = {.count = 1, .reusable = true}}, SHIFT(483), + [954] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__name_list, 2, 0, 14), + [956] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__singlequote_string_content, 1, 0, 0), + [958] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__singlequote_string_content, 1, 0, 0), + [960] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_elseif_statement, 4, 0, 56), + [962] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_elseif_statement, 4, 0, 56), + [964] = {.entry = {.count = 1, .reusable = true}}, SHIFT(460), + [966] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__vararg_parameter, 1, 0, 0), + [968] = {.entry = {.count = 1, .reusable = true}}, SHIFT(448), + [970] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_generic_clause, 3, 0, 33), + [972] = {.entry = {.count = 1, .reusable = true}}, SHIFT(162), + [974] = {.entry = {.count = 1, .reusable = true}}, SHIFT(104), + [976] = {.entry = {.count = 1, .reusable = true}}, SHIFT(235), + [978] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_name, 1, 0, 8), + [980] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33), + [982] = {.entry = {.count = 1, .reusable = true}}, SHIFT(18), + [984] = {.entry = {.count = 1, .reusable = true}}, SHIFT(290), + [986] = {.entry = {.count = 1, .reusable = true}}, SHIFT(355), + [988] = {.entry = {.count = 1, .reusable = true}}, SHIFT(20), + [990] = {.entry = {.count = 1, .reusable = true}}, SHIFT(234), + [992] = {.entry = {.count = 1, .reusable = true}}, SHIFT(404), + [994] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_else_statement, 2, 0, 20), + [996] = {.entry = {.count = 1, .reusable = true}}, SHIFT(296), + [998] = {.entry = {.count = 1, .reusable = true}}, SHIFT(327), + [1000] = {.entry = {.count = 1, .reusable = true}}, SHIFT(258), + [1002] = {.entry = {.count = 1, .reusable = true}}, SHIFT(240), + [1004] = {.entry = {.count = 1, .reusable = true}}, SHIFT(420), + [1006] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93), + [1008] = {.entry = {.count = 1, .reusable = true}}, SHIFT(306), + [1010] = {.entry = {.count = 1, .reusable = true}}, SHIFT(185), + [1012] = {.entry = {.count = 1, .reusable = true}}, SHIFT(308), + [1014] = {.entry = {.count = 1, .reusable = true}}, SHIFT(487), + [1016] = {.entry = {.count = 1, .reusable = true}}, SHIFT(310), + [1018] = {.entry = {.count = 1, .reusable = true}}, SHIFT(291), + [1020] = {.entry = {.count = 1, .reusable = false}}, SHIFT(305), + [1022] = {.entry = {.count = 1, .reusable = true}}, SHIFT(312), + [1024] = {.entry = {.count = 1, .reusable = true}}, SHIFT(332), + [1026] = {.entry = {.count = 1, .reusable = true}}, SHIFT(314), + [1028] = {.entry = {.count = 1, .reusable = true}}, SHIFT(316), + [1030] = {.entry = {.count = 1, .reusable = true}}, SHIFT(482), + [1032] = {.entry = {.count = 1, .reusable = true}}, SHIFT(141), + [1034] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_name_method_index_expression, 3, 0, 29), + [1036] = {.entry = {.count = 1, .reusable = true}}, SHIFT(99), + [1038] = {.entry = {.count = 1, .reusable = true}}, SHIFT(143), + [1040] = {.entry = {.count = 1, .reusable = false}}, SHIFT(273), + [1042] = {.entry = {.count = 1, .reusable = true}}, SHIFT(101), + [1044] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54), + [1046] = {.entry = {.count = 1, .reusable = false}}, SHIFT(489), + [1048] = {.entry = {.count = 1, .reusable = true}}, SHIFT(279), + [1050] = {.entry = {.count = 1, .reusable = true}}, SHIFT(40), + [1052] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__parameter_list, 4, 0, 70), + [1054] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__parameter_list, 1, 0, 33), + [1056] = {.entry = {.count = 1, .reusable = true}}, SHIFT(26), + [1058] = {.entry = {.count = 1, .reusable = true}}, SHIFT(478), + [1060] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__vararg_parameter, 2, 0, 30), + [1062] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60), + [1064] = {.entry = {.count = 1, .reusable = true}}, SHIFT(419), + [1066] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_chunk, 3, 0, 0), + [1068] = {.entry = {.count = 1, .reusable = true}}, SHIFT(45), + [1070] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), + [1072] = {.entry = {.count = 1, .reusable = true}}, SHIFT(464), + [1074] = {.entry = {.count = 1, .reusable = true}}, SHIFT(118), + [1076] = {.entry = {.count = 1, .reusable = true}}, SHIFT(397), + [1078] = {.entry = {.count = 1, .reusable = true}}, SHIFT(429), + [1080] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3), + [1082] = {.entry = {.count = 1, .reusable = true}}, SHIFT(137), + [1084] = {.entry = {.count = 1, .reusable = true}}, SHIFT(233), + [1086] = {.entry = {.count = 1, .reusable = true}}, SHIFT(455), + [1088] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__parameter_list, 3, 0, 65), + [1090] = {.entry = {.count = 1, .reusable = true}}, SHIFT(265), + [1092] = {.entry = {.count = 1, .reusable = true}}, SHIFT(289), + [1094] = {.entry = {.count = 1, .reusable = true}}, SHIFT(322), + [1096] = {.entry = {.count = 1, .reusable = true}}, SHIFT(180), + [1098] = {.entry = {.count = 1, .reusable = true}}, SHIFT(323), + [1100] = {.entry = {.count = 1, .reusable = true}}, SHIFT(395), + [1102] = {.entry = {.count = 1, .reusable = true}}, SHIFT(254), + [1104] = {.entry = {.count = 1, .reusable = true}}, SHIFT(447), + [1106] = {.entry = {.count = 1, .reusable = true}}, SHIFT(267), + [1108] = {.entry = {.count = 1, .reusable = true}}, SHIFT(285), + [1110] = {.entry = {.count = 1, .reusable = true}}, SHIFT(282), + [1112] = {.entry = {.count = 1, .reusable = true}}, SHIFT(488), + [1114] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_comment, 3, 0, 15), + [1116] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_comment, 2, 0, 5), +}; + +enum ts_external_scanner_symbol_identifiers { + ts_external_token__block_comment_start = 0, + ts_external_token__block_comment_content = 1, + ts_external_token__block_comment_end = 2, + ts_external_token__block_string_start = 3, + ts_external_token__block_string_content = 4, + ts_external_token__block_string_end = 5, +}; + +static const TSSymbol ts_external_scanner_symbol_map[EXTERNAL_TOKEN_COUNT] = { + [ts_external_token__block_comment_start] = sym__block_comment_start, + [ts_external_token__block_comment_content] = sym__block_comment_content, + [ts_external_token__block_comment_end] = sym__block_comment_end, + [ts_external_token__block_string_start] = sym__block_string_start, + [ts_external_token__block_string_content] = sym__block_string_content, + [ts_external_token__block_string_end] = sym__block_string_end, +}; + +static const bool ts_external_scanner_states[8][EXTERNAL_TOKEN_COUNT] = { + [1] = { + [ts_external_token__block_comment_start] = true, + [ts_external_token__block_comment_content] = true, + [ts_external_token__block_comment_end] = true, + [ts_external_token__block_string_start] = true, + [ts_external_token__block_string_content] = true, + [ts_external_token__block_string_end] = true, + }, + [2] = { + [ts_external_token__block_comment_start] = true, + }, + [3] = { + [ts_external_token__block_comment_start] = true, + [ts_external_token__block_string_start] = true, + }, + [4] = { + [ts_external_token__block_comment_start] = true, + [ts_external_token__block_string_content] = true, + }, + [5] = { + [ts_external_token__block_comment_start] = true, + [ts_external_token__block_string_end] = true, + }, + [6] = { + [ts_external_token__block_comment_start] = true, + [ts_external_token__block_comment_content] = true, + }, + [7] = { + [ts_external_token__block_comment_start] = true, + [ts_external_token__block_comment_end] = true, + }, +}; + +#ifdef __cplusplus +extern "C" { +#endif +void *tree_sitter_pico8_lua_external_scanner_create(void); +void tree_sitter_pico8_lua_external_scanner_destroy(void *); +bool tree_sitter_pico8_lua_external_scanner_scan(void *, TSLexer *, const bool *); +unsigned tree_sitter_pico8_lua_external_scanner_serialize(void *, char *); +void tree_sitter_pico8_lua_external_scanner_deserialize(void *, const char *, unsigned); + +#ifdef TREE_SITTER_HIDE_SYMBOLS +#define TS_PUBLIC +#elif defined(_WIN32) +#define TS_PUBLIC __declspec(dllexport) +#else +#define TS_PUBLIC __attribute__((visibility("default"))) +#endif + +TS_PUBLIC const TSLanguage *tree_sitter_pico8_lua(void) { + static const TSLanguage language = { + .version = LANGUAGE_VERSION, + .symbol_count = SYMBOL_COUNT, + .alias_count = ALIAS_COUNT, + .token_count = TOKEN_COUNT, + .external_token_count = EXTERNAL_TOKEN_COUNT, + .state_count = STATE_COUNT, + .large_state_count = LARGE_STATE_COUNT, + .production_id_count = PRODUCTION_ID_COUNT, + .field_count = FIELD_COUNT, + .max_alias_sequence_length = MAX_ALIAS_SEQUENCE_LENGTH, + .parse_table = &ts_parse_table[0][0], + .small_parse_table = ts_small_parse_table, + .small_parse_table_map = ts_small_parse_table_map, + .parse_actions = ts_parse_actions, + .symbol_names = ts_symbol_names, + .field_names = ts_field_names, + .field_map_slices = ts_field_map_slices, + .field_map_entries = ts_field_map_entries, + .symbol_metadata = ts_symbol_metadata, + .public_symbol_map = ts_symbol_map, + .alias_map = ts_non_terminal_alias_map, + .alias_sequences = &ts_alias_sequences[0][0], + .lex_modes = ts_lex_modes, + .lex_fn = ts_lex, + .keyword_lex_fn = ts_lex_keywords, + .keyword_capture_token = sym_identifier, + .external_scanner = { + &ts_external_scanner_states[0][0], + ts_external_scanner_symbol_map, + tree_sitter_pico8_lua_external_scanner_create, + tree_sitter_pico8_lua_external_scanner_destroy, + tree_sitter_pico8_lua_external_scanner_scan, + tree_sitter_pico8_lua_external_scanner_serialize, + tree_sitter_pico8_lua_external_scanner_deserialize, + }, + .primary_state_ids = ts_primary_state_ids, + }; + return &language; +} +#ifdef __cplusplus +} +#endif diff --git a/grammars/pico-8-lua/src/scanner.c b/grammars/pico-8-lua/src/scanner.c new file mode 100644 index 0000000..0ef5459 --- /dev/null +++ b/grammars/pico-8-lua/src/scanner.c @@ -0,0 +1,195 @@ +#include +#include "tree_sitter/alloc.h" +#include "tree_sitter/parser.h" +#include + +enum TokenType { + BLOCK_COMMENT_START, + BLOCK_COMMENT_CONTENT, + BLOCK_COMMENT_END, + + BLOCK_STRING_START, + BLOCK_STRING_CONTENT, + BLOCK_STRING_END, +}; + +static inline void consume(TSLexer *lexer) { lexer->advance(lexer, false); } + +static inline void skip(TSLexer *lexer) { lexer->advance(lexer, true); } + +static inline bool consume_char(char c, TSLexer *lexer) { + if (lexer->lookahead != c) { + return false; + } + + consume(lexer); + return true; +} + +static inline uint8_t consume_and_count_char(char c, TSLexer *lexer) { + uint8_t count = 0; + while (lexer->lookahead == c) { + ++count; + consume(lexer); + } + return count; +} + +static inline void skip_whitespaces(TSLexer *lexer) { + while (iswspace(lexer->lookahead)) { + skip(lexer); + } +} + +typedef struct { + char ending_char; + uint8_t level_count; +} Scanner; + +static inline void reset_state(Scanner *scanner) { + scanner->ending_char = 0; + scanner->level_count = 0; +} + +void *tree_sitter_pico8_lua_external_scanner_create() { + Scanner *scanner = ts_calloc(1, sizeof(Scanner)); + return scanner; +} + +void tree_sitter_pico8_lua_external_scanner_destroy(void *payload) { + Scanner *scanner = (Scanner *)payload; + ts_free(scanner); +} + +unsigned tree_sitter_pico8_lua_external_scanner_serialize(void *payload, char *buffer) { + Scanner *scanner = (Scanner *)payload; + buffer[0] = scanner->ending_char; + buffer[1] = (char)scanner->level_count; + return 2; +} + +void tree_sitter_pico8_lua_external_scanner_deserialize(void *payload, const char *buffer, unsigned length) { + Scanner *scanner = (Scanner *)payload; + if (length == 0) return; + scanner->ending_char = buffer[0]; + if (length == 1) return; + scanner->level_count = buffer[1]; +} + +static bool scan_block_start(Scanner *scanner, TSLexer *lexer) { + if (consume_char('[', lexer)) { + uint8_t level = consume_and_count_char('=', lexer); + + if (consume_char('[', lexer)) { + scanner->level_count = level; + return true; + } + } + + return false; +} + +static bool scan_block_end(Scanner *scanner, TSLexer *lexer) { + if (consume_char(']', lexer)) { + uint8_t level = consume_and_count_char('=', lexer); + + if (scanner->level_count == level && consume_char(']', lexer)) { + return true; + } + } + + return false; +} + +static bool scan_block_content(Scanner *scanner, TSLexer *lexer) { + while (lexer->lookahead != 0) { + if (lexer->lookahead == ']') { + lexer->mark_end(lexer); + + if (scan_block_end(scanner, lexer)) { + return true; + } + } else { + consume(lexer); + } + } + + return false; +} + +static bool scan_comment_start(Scanner *scanner, TSLexer *lexer) { + if (consume_char('-', lexer) && consume_char('-', lexer)) { + lexer->mark_end(lexer); + + if (scan_block_start(scanner, lexer)) { + lexer->mark_end(lexer); + lexer->result_symbol = BLOCK_COMMENT_START; + return true; + } + } + + return false; +} + +static bool scan_comment_content(Scanner *scanner, TSLexer *lexer) { + if (scanner->ending_char == 0) { // block comment + if (scan_block_content(scanner, lexer)) { + lexer->result_symbol = BLOCK_COMMENT_CONTENT; + return true; + } + + return false; + } + + while (lexer->lookahead != 0) { + if (lexer->lookahead == scanner->ending_char) { + reset_state(scanner); + lexer->result_symbol = BLOCK_COMMENT_CONTENT; + return true; + } + + consume(lexer); + } + + return false; +} + +bool tree_sitter_pico8_lua_external_scanner_scan(void *payload, TSLexer *lexer, const bool *valid_symbols) { + Scanner *scanner = (Scanner *)payload; + + if (valid_symbols[BLOCK_STRING_END] && scan_block_end(scanner, lexer)) { + reset_state(scanner); + lexer->result_symbol = BLOCK_STRING_END; + return true; + } + + if (valid_symbols[BLOCK_STRING_CONTENT] && scan_block_content(scanner, lexer)) { + lexer->result_symbol = BLOCK_STRING_CONTENT; + return true; + } + + if (valid_symbols[BLOCK_COMMENT_END] && scanner->ending_char == 0 && scan_block_end(scanner, lexer)) { + reset_state(scanner); + lexer->result_symbol = BLOCK_COMMENT_END; + return true; + } + + if (valid_symbols[BLOCK_COMMENT_CONTENT] && scan_comment_content(scanner, lexer)) { + return true; + } + + skip_whitespaces(lexer); + + if (valid_symbols[BLOCK_STRING_START] && scan_block_start(scanner, lexer)) { + lexer->result_symbol = BLOCK_STRING_START; + return true; + } + + if (valid_symbols[BLOCK_COMMENT_START]) { + if (scan_comment_start(scanner, lexer)) { + return true; + } + } + + return false; +} diff --git a/grammars/pico-8-lua/src/tree_sitter/alloc.h b/grammars/pico-8-lua/src/tree_sitter/alloc.h new file mode 100644 index 0000000..1abdd12 --- /dev/null +++ b/grammars/pico-8-lua/src/tree_sitter/alloc.h @@ -0,0 +1,54 @@ +#ifndef TREE_SITTER_ALLOC_H_ +#define TREE_SITTER_ALLOC_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include + +// Allow clients to override allocation functions +#ifdef TREE_SITTER_REUSE_ALLOCATOR + +extern void *(*ts_current_malloc)(size_t size); +extern void *(*ts_current_calloc)(size_t count, size_t size); +extern void *(*ts_current_realloc)(void *ptr, size_t size); +extern void (*ts_current_free)(void *ptr); + +#ifndef ts_malloc +#define ts_malloc ts_current_malloc +#endif +#ifndef ts_calloc +#define ts_calloc ts_current_calloc +#endif +#ifndef ts_realloc +#define ts_realloc ts_current_realloc +#endif +#ifndef ts_free +#define ts_free ts_current_free +#endif + +#else + +#ifndef ts_malloc +#define ts_malloc malloc +#endif +#ifndef ts_calloc +#define ts_calloc calloc +#endif +#ifndef ts_realloc +#define ts_realloc realloc +#endif +#ifndef ts_free +#define ts_free free +#endif + +#endif + +#ifdef __cplusplus +} +#endif + +#endif // TREE_SITTER_ALLOC_H_ diff --git a/grammars/pico-8-lua/src/tree_sitter/array.h b/grammars/pico-8-lua/src/tree_sitter/array.h new file mode 100644 index 0000000..a17a574 --- /dev/null +++ b/grammars/pico-8-lua/src/tree_sitter/array.h @@ -0,0 +1,291 @@ +#ifndef TREE_SITTER_ARRAY_H_ +#define TREE_SITTER_ARRAY_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "./alloc.h" + +#include +#include +#include +#include +#include + +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable : 4101) +#elif defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-variable" +#endif + +#define Array(T) \ + struct { \ + T *contents; \ + uint32_t size; \ + uint32_t capacity; \ + } + +/// Initialize an array. +#define array_init(self) \ + ((self)->size = 0, (self)->capacity = 0, (self)->contents = NULL) + +/// Create an empty array. +#define array_new() \ + { NULL, 0, 0 } + +/// Get a pointer to the element at a given `index` in the array. +#define array_get(self, _index) \ + (assert((uint32_t)(_index) < (self)->size), &(self)->contents[_index]) + +/// Get a pointer to the first element in the array. +#define array_front(self) array_get(self, 0) + +/// Get a pointer to the last element in the array. +#define array_back(self) array_get(self, (self)->size - 1) + +/// Clear the array, setting its size to zero. Note that this does not free any +/// memory allocated for the array's contents. +#define array_clear(self) ((self)->size = 0) + +/// Reserve `new_capacity` elements of space in the array. If `new_capacity` is +/// less than the array's current capacity, this function has no effect. +#define array_reserve(self, new_capacity) \ + _array__reserve((Array *)(self), array_elem_size(self), new_capacity) + +/// Free any memory allocated for this array. Note that this does not free any +/// memory allocated for the array's contents. +#define array_delete(self) _array__delete((Array *)(self)) + +/// Push a new `element` onto the end of the array. +#define array_push(self, element) \ + (_array__grow((Array *)(self), 1, array_elem_size(self)), \ + (self)->contents[(self)->size++] = (element)) + +/// Increase the array's size by `count` elements. +/// New elements are zero-initialized. +#define array_grow_by(self, count) \ + do { \ + if ((count) == 0) break; \ + _array__grow((Array *)(self), count, array_elem_size(self)); \ + memset((self)->contents + (self)->size, 0, (count) * array_elem_size(self)); \ + (self)->size += (count); \ + } while (0) + +/// Append all elements from one array to the end of another. +#define array_push_all(self, other) \ + array_extend((self), (other)->size, (other)->contents) + +/// Append `count` elements to the end of the array, reading their values from the +/// `contents` pointer. +#define array_extend(self, count, contents) \ + _array__splice( \ + (Array *)(self), array_elem_size(self), (self)->size, \ + 0, count, contents \ + ) + +/// Remove `old_count` elements from the array starting at the given `index`. At +/// the same index, insert `new_count` new elements, reading their values from the +/// `new_contents` pointer. +#define array_splice(self, _index, old_count, new_count, new_contents) \ + _array__splice( \ + (Array *)(self), array_elem_size(self), _index, \ + old_count, new_count, new_contents \ + ) + +/// Insert one `element` into the array at the given `index`. +#define array_insert(self, _index, element) \ + _array__splice((Array *)(self), array_elem_size(self), _index, 0, 1, &(element)) + +/// Remove one element from the array at the given `index`. +#define array_erase(self, _index) \ + _array__erase((Array *)(self), array_elem_size(self), _index) + +/// Pop the last element off the array, returning the element by value. +#define array_pop(self) ((self)->contents[--(self)->size]) + +/// Assign the contents of one array to another, reallocating if necessary. +#define array_assign(self, other) \ + _array__assign((Array *)(self), (const Array *)(other), array_elem_size(self)) + +/// Swap one array with another +#define array_swap(self, other) \ + _array__swap((Array *)(self), (Array *)(other)) + +/// Get the size of the array contents +#define array_elem_size(self) (sizeof *(self)->contents) + +/// Search a sorted array for a given `needle` value, using the given `compare` +/// callback to determine the order. +/// +/// If an existing element is found to be equal to `needle`, then the `index` +/// out-parameter is set to the existing value's index, and the `exists` +/// out-parameter is set to true. Otherwise, `index` is set to an index where +/// `needle` should be inserted in order to preserve the sorting, and `exists` +/// is set to false. +#define array_search_sorted_with(self, compare, needle, _index, _exists) \ + _array__search_sorted(self, 0, compare, , needle, _index, _exists) + +/// Search a sorted array for a given `needle` value, using integer comparisons +/// of a given struct field (specified with a leading dot) to determine the order. +/// +/// See also `array_search_sorted_with`. +#define array_search_sorted_by(self, field, needle, _index, _exists) \ + _array__search_sorted(self, 0, _compare_int, field, needle, _index, _exists) + +/// Insert a given `value` into a sorted array, using the given `compare` +/// callback to determine the order. +#define array_insert_sorted_with(self, compare, value) \ + do { \ + unsigned _index, _exists; \ + array_search_sorted_with(self, compare, &(value), &_index, &_exists); \ + if (!_exists) array_insert(self, _index, value); \ + } while (0) + +/// Insert a given `value` into a sorted array, using integer comparisons of +/// a given struct field (specified with a leading dot) to determine the order. +/// +/// See also `array_search_sorted_by`. +#define array_insert_sorted_by(self, field, value) \ + do { \ + unsigned _index, _exists; \ + array_search_sorted_by(self, field, (value) field, &_index, &_exists); \ + if (!_exists) array_insert(self, _index, value); \ + } while (0) + +// Private + +typedef Array(void) Array; + +/// This is not what you're looking for, see `array_delete`. +static inline void _array__delete(Array *self) { + if (self->contents) { + ts_free(self->contents); + self->contents = NULL; + self->size = 0; + self->capacity = 0; + } +} + +/// This is not what you're looking for, see `array_erase`. +static inline void _array__erase(Array *self, size_t element_size, + uint32_t index) { + assert(index < self->size); + char *contents = (char *)self->contents; + memmove(contents + index * element_size, contents + (index + 1) * element_size, + (self->size - index - 1) * element_size); + self->size--; +} + +/// This is not what you're looking for, see `array_reserve`. +static inline void _array__reserve(Array *self, size_t element_size, uint32_t new_capacity) { + if (new_capacity > self->capacity) { + if (self->contents) { + self->contents = ts_realloc(self->contents, new_capacity * element_size); + } else { + self->contents = ts_malloc(new_capacity * element_size); + } + self->capacity = new_capacity; + } +} + +/// This is not what you're looking for, see `array_assign`. +static inline void _array__assign(Array *self, const Array *other, size_t element_size) { + _array__reserve(self, element_size, other->size); + self->size = other->size; + memcpy(self->contents, other->contents, self->size * element_size); +} + +/// This is not what you're looking for, see `array_swap`. +static inline void _array__swap(Array *self, Array *other) { + Array swap = *other; + *other = *self; + *self = swap; +} + +/// This is not what you're looking for, see `array_push` or `array_grow_by`. +static inline void _array__grow(Array *self, uint32_t count, size_t element_size) { + uint32_t new_size = self->size + count; + if (new_size > self->capacity) { + uint32_t new_capacity = self->capacity * 2; + if (new_capacity < 8) new_capacity = 8; + if (new_capacity < new_size) new_capacity = new_size; + _array__reserve(self, element_size, new_capacity); + } +} + +/// This is not what you're looking for, see `array_splice`. +static inline void _array__splice(Array *self, size_t element_size, + uint32_t index, uint32_t old_count, + uint32_t new_count, const void *elements) { + uint32_t new_size = self->size + new_count - old_count; + uint32_t old_end = index + old_count; + uint32_t new_end = index + new_count; + assert(old_end <= self->size); + + _array__reserve(self, element_size, new_size); + + char *contents = (char *)self->contents; + if (self->size > old_end) { + memmove( + contents + new_end * element_size, + contents + old_end * element_size, + (self->size - old_end) * element_size + ); + } + if (new_count > 0) { + if (elements) { + memcpy( + (contents + index * element_size), + elements, + new_count * element_size + ); + } else { + memset( + (contents + index * element_size), + 0, + new_count * element_size + ); + } + } + self->size += new_count - old_count; +} + +/// A binary search routine, based on Rust's `std::slice::binary_search_by`. +/// This is not what you're looking for, see `array_search_sorted_with` or `array_search_sorted_by`. +#define _array__search_sorted(self, start, compare, suffix, needle, _index, _exists) \ + do { \ + *(_index) = start; \ + *(_exists) = false; \ + uint32_t size = (self)->size - *(_index); \ + if (size == 0) break; \ + int comparison; \ + while (size > 1) { \ + uint32_t half_size = size / 2; \ + uint32_t mid_index = *(_index) + half_size; \ + comparison = compare(&((self)->contents[mid_index] suffix), (needle)); \ + if (comparison <= 0) *(_index) = mid_index; \ + size -= half_size; \ + } \ + comparison = compare(&((self)->contents[*(_index)] suffix), (needle)); \ + if (comparison == 0) *(_exists) = true; \ + else if (comparison < 0) *(_index) += 1; \ + } while (0) + +/// Helper macro for the `_sorted_by` routines below. This takes the left (existing) +/// parameter by reference in order to work with the generic sorting function above. +#define _compare_int(a, b) ((int)*(a) - (int)(b)) + +#ifdef _MSC_VER +#pragma warning(pop) +#elif defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic pop +#endif + +#ifdef __cplusplus +} +#endif + +#endif // TREE_SITTER_ARRAY_H_ diff --git a/grammars/pico-8-lua/src/tree_sitter/parser.h b/grammars/pico-8-lua/src/tree_sitter/parser.h new file mode 100644 index 0000000..799f599 --- /dev/null +++ b/grammars/pico-8-lua/src/tree_sitter/parser.h @@ -0,0 +1,266 @@ +#ifndef TREE_SITTER_PARSER_H_ +#define TREE_SITTER_PARSER_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include + +#define ts_builtin_sym_error ((TSSymbol)-1) +#define ts_builtin_sym_end 0 +#define TREE_SITTER_SERIALIZATION_BUFFER_SIZE 1024 + +#ifndef TREE_SITTER_API_H_ +typedef uint16_t TSStateId; +typedef uint16_t TSSymbol; +typedef uint16_t TSFieldId; +typedef struct TSLanguage TSLanguage; +#endif + +typedef struct { + TSFieldId field_id; + uint8_t child_index; + bool inherited; +} TSFieldMapEntry; + +typedef struct { + uint16_t index; + uint16_t length; +} TSFieldMapSlice; + +typedef struct { + bool visible; + bool named; + bool supertype; +} TSSymbolMetadata; + +typedef struct TSLexer TSLexer; + +struct TSLexer { + int32_t lookahead; + TSSymbol result_symbol; + void (*advance)(TSLexer *, bool); + void (*mark_end)(TSLexer *); + uint32_t (*get_column)(TSLexer *); + bool (*is_at_included_range_start)(const TSLexer *); + bool (*eof)(const TSLexer *); + void (*log)(const TSLexer *, const char *, ...); +}; + +typedef enum { + TSParseActionTypeShift, + TSParseActionTypeReduce, + TSParseActionTypeAccept, + TSParseActionTypeRecover, +} TSParseActionType; + +typedef union { + struct { + uint8_t type; + TSStateId state; + bool extra; + bool repetition; + } shift; + struct { + uint8_t type; + uint8_t child_count; + TSSymbol symbol; + int16_t dynamic_precedence; + uint16_t production_id; + } reduce; + uint8_t type; +} TSParseAction; + +typedef struct { + uint16_t lex_state; + uint16_t external_lex_state; +} TSLexMode; + +typedef union { + TSParseAction action; + struct { + uint8_t count; + bool reusable; + } entry; +} TSParseActionEntry; + +typedef struct { + int32_t start; + int32_t end; +} TSCharacterRange; + +struct TSLanguage { + uint32_t version; + uint32_t symbol_count; + uint32_t alias_count; + uint32_t token_count; + uint32_t external_token_count; + uint32_t state_count; + uint32_t large_state_count; + uint32_t production_id_count; + uint32_t field_count; + uint16_t max_alias_sequence_length; + const uint16_t *parse_table; + const uint16_t *small_parse_table; + const uint32_t *small_parse_table_map; + const TSParseActionEntry *parse_actions; + const char * const *symbol_names; + const char * const *field_names; + const TSFieldMapSlice *field_map_slices; + const TSFieldMapEntry *field_map_entries; + const TSSymbolMetadata *symbol_metadata; + const TSSymbol *public_symbol_map; + const uint16_t *alias_map; + const TSSymbol *alias_sequences; + const TSLexMode *lex_modes; + bool (*lex_fn)(TSLexer *, TSStateId); + bool (*keyword_lex_fn)(TSLexer *, TSStateId); + TSSymbol keyword_capture_token; + struct { + const bool *states; + const TSSymbol *symbol_map; + void *(*create)(void); + void (*destroy)(void *); + bool (*scan)(void *, TSLexer *, const bool *symbol_whitelist); + unsigned (*serialize)(void *, char *); + void (*deserialize)(void *, const char *, unsigned); + } external_scanner; + const TSStateId *primary_state_ids; +}; + +static inline bool set_contains(TSCharacterRange *ranges, uint32_t len, int32_t lookahead) { + uint32_t index = 0; + uint32_t size = len - index; + while (size > 1) { + uint32_t half_size = size / 2; + uint32_t mid_index = index + half_size; + TSCharacterRange *range = &ranges[mid_index]; + if (lookahead >= range->start && lookahead <= range->end) { + return true; + } else if (lookahead > range->end) { + index = mid_index; + } + size -= half_size; + } + TSCharacterRange *range = &ranges[index]; + return (lookahead >= range->start && lookahead <= range->end); +} + +/* + * Lexer Macros + */ + +#ifdef _MSC_VER +#define UNUSED __pragma(warning(suppress : 4101)) +#else +#define UNUSED __attribute__((unused)) +#endif + +#define START_LEXER() \ + bool result = false; \ + bool skip = false; \ + UNUSED \ + bool eof = false; \ + int32_t lookahead; \ + goto start; \ + next_state: \ + lexer->advance(lexer, skip); \ + start: \ + skip = false; \ + lookahead = lexer->lookahead; + +#define ADVANCE(state_value) \ + { \ + state = state_value; \ + goto next_state; \ + } + +#define ADVANCE_MAP(...) \ + { \ + static const uint16_t map[] = { __VA_ARGS__ }; \ + for (uint32_t i = 0; i < sizeof(map) / sizeof(map[0]); i += 2) { \ + if (map[i] == lookahead) { \ + state = map[i + 1]; \ + goto next_state; \ + } \ + } \ + } + +#define SKIP(state_value) \ + { \ + skip = true; \ + state = state_value; \ + goto next_state; \ + } + +#define ACCEPT_TOKEN(symbol_value) \ + result = true; \ + lexer->result_symbol = symbol_value; \ + lexer->mark_end(lexer); + +#define END_STATE() return result; + +/* + * Parse Table Macros + */ + +#define SMALL_STATE(id) ((id) - LARGE_STATE_COUNT) + +#define STATE(id) id + +#define ACTIONS(id) id + +#define SHIFT(state_value) \ + {{ \ + .shift = { \ + .type = TSParseActionTypeShift, \ + .state = (state_value) \ + } \ + }} + +#define SHIFT_REPEAT(state_value) \ + {{ \ + .shift = { \ + .type = TSParseActionTypeShift, \ + .state = (state_value), \ + .repetition = true \ + } \ + }} + +#define SHIFT_EXTRA() \ + {{ \ + .shift = { \ + .type = TSParseActionTypeShift, \ + .extra = true \ + } \ + }} + +#define REDUCE(symbol_name, children, precedence, prod_id) \ + {{ \ + .reduce = { \ + .type = TSParseActionTypeReduce, \ + .symbol = symbol_name, \ + .child_count = children, \ + .dynamic_precedence = precedence, \ + .production_id = prod_id \ + }, \ + }} + +#define RECOVER() \ + {{ \ + .type = TSParseActionTypeRecover \ + }} + +#define ACCEPT_INPUT() \ + {{ \ + .type = TSParseActionTypeAccept \ + }} + +#ifdef __cplusplus +} +#endif + +#endif // TREE_SITTER_PARSER_H_ diff --git a/grammars/pico-8-lua/tree-sitter.json b/grammars/pico-8-lua/tree-sitter.json new file mode 100644 index 0000000..3326635 --- /dev/null +++ b/grammars/pico-8-lua/tree-sitter.json @@ -0,0 +1,27 @@ +{ + "$schema": "https://tree-sitter.github.io/tree-sitter/assets/schemas/config.schema.json", + "grammars": [ + { + "name": "pico8_lua", + "scope": "source.pico8-lua", + "path": ".", + "file-types": [ + "p8lua" + ], + "injection-regex": "^pico-?8[-_ ]?lua$" + } + ], + "metadata": { + "version": "0.0.1", + "license": "MIT", + "description": "PICO-8 Lua dialect grammar (forked from tree-sitter-lua)" + }, + "bindings": { + "c": true, + "go": false, + "node": true, + "python": false, + "rust": false, + "swift": false + } +} diff --git a/languages/pico-8-cart/injections.scm b/languages/pico-8-cart/injections.scm index af96ca8..ad5251d 100644 --- a/languages/pico-8-cart/injections.scm +++ b/languages/pico-8-cart/injections.scm @@ -1,11 +1,5 @@ -; Inject Lua syntax highlighting into the __lua__ section. -; -; NOTE: This injects Zed's built-in Lua grammar, which does not -; understand Pico-8 dialect extensions ( ?, +=, !=, single-line -; `if (cond) stmt`, binary literals, memory peek prefix operators, -; etc. ). Code that uses those forms will produce parse errors -; locally, with degraded highlighting in those regions only — the -; rest of the file will still render correctly. A future Pico-8 -; Lua grammar fork will replace this; see README for status. +; Hand the body of the __lua__ section to the Pico-8 Lua grammar so the +; dialect-aware parser parses it (compound-assignment statements, the `?` +; print shorthand, single-line `if (cond) stmt`, peek prefixes, etc.). ((lua_content) @injection.content - (#set! injection.language "lua")) + (#set! injection.language "pico-8-lua")) diff --git a/languages/pico-8-lua/brackets.scm b/languages/pico-8-lua/brackets.scm new file mode 100644 index 0000000..2fbfd44 --- /dev/null +++ b/languages/pico-8-lua/brackets.scm @@ -0,0 +1,4 @@ +("(" @open ")" @close) +("[" @open "]" @close) +("{" @open "}" @close) +("\"" @open "\"" @close) diff --git a/languages/pico-8-lua/config.toml b/languages/pico-8-lua/config.toml new file mode 100644 index 0000000..29f9a19 --- /dev/null +++ b/languages/pico-8-lua/config.toml @@ -0,0 +1,16 @@ +name = "Pico-8 Lua" +grammar = "pico8_lua" +path_suffixes = ["p8lua"] +line_comments = ["-- "] +block_comment = ["--[[", "]]"] +hard_tabs = false +tab_size = 1 +autoclose_before = ";:.,=}])>" +brackets = [ + { start = "{", end = "}", close = true, newline = true }, + { start = "[", end = "]", close = true, newline = true }, + { start = "(", end = ")", close = true, newline = true }, + { start = "\"", end = "\"", close = true, newline = false, not_in = ["string"] }, + { start = "'", end = "'", close = true, newline = false, not_in = ["string", "comment"] }, + { start = "[[", end = "]]", close = true, newline = true }, +] diff --git a/languages/pico-8-lua/highlights.scm b/languages/pico-8-lua/highlights.scm new file mode 100644 index 0000000..d28bb69 --- /dev/null +++ b/languages/pico-8-lua/highlights.scm @@ -0,0 +1,215 @@ +; --- Keywords --- + +"return" @keyword.return + +[ + "goto" + "in" + "local" +] @keyword + +(label_statement) @label +(break_statement) @keyword + +(do_statement + ["do" "end"] @keyword) + +(while_statement + ["while" "do" "end"] @keyword.repeat) +(shorthand_while_statement + "while" @keyword.repeat) + +(repeat_statement + ["repeat" "until"] @keyword.repeat) + +(if_statement + ["if" "elseif" "else" "then" "end"] @keyword.conditional) +(elseif_statement + ["elseif" "then" "end"] @keyword.conditional) +(else_statement + ["else" "end"] @keyword.conditional) +(shorthand_if_statement + ["if" "else"] @keyword.conditional) + +(for_statement + ["for" "do" "end"] @keyword.repeat) + +(function_declaration + ["function" "end"] @keyword.function) +(function_definition + ["function" "end"] @keyword.function) + +; --- PICO-8 dialect: print shorthand and #include --- + +(print_shorthand_statement + directive: "?" @function.builtin) + +(include_statement + directive: _ @keyword.directive) +(include_statement + path: (include_path) @string.special.path) + +; --- Operators --- + +(binary_expression + operator: _ @operator) + +(unary_expression + operator: _ @operator) + +(compound_assignment_statement + operator: _ @operator) + +"=" @operator + +[ + "and" + "not" + "or" +] @keyword.operator + +; --- Punctuation --- + +[ + ";" + ":" + "," + "." +] @punctuation.delimiter + +[ + "(" + ")" + "[" + "]" + "{" + "}" +] @punctuation.bracket + +; --- Variables and constants --- + +(identifier) @variable + +(variable_list + (attribute + "<" @punctuation.bracket + (identifier) @attribute + ">" @punctuation.bracket)) + +((identifier) @constant + (#match? @constant "^[A-Z][A-Z_0-9]*$")) + +(vararg_expression) @constant +(nil) @constant.builtin + +[ + (false) + (true) +] @boolean + +; PICO-8 callback hooks — recognized by name regardless of definition site. +((identifier) @function.builtin + (#any-of? @function.builtin + "_init" "_update" "_update60" "_draw")) + +; --- Tables --- + +(field + name: (identifier) @property) + +(dot_index_expression + field: (identifier) @property) + +(table_constructor + ["{" "}"] @constructor) + +; --- Functions --- + +(parameters + (identifier) @variable.parameter) + +(function_declaration + name: [ + (identifier) @function + (dot_index_expression + field: (identifier) @function) + ]) + +(function_declaration + name: (method_index_expression + method: (identifier) @function.method)) + +(assignment_statement + (variable_list + . + name: [ + (identifier) @function + (dot_index_expression + field: (identifier) @function) + ]) + (expression_list + . + value: (function_definition))) + +(table_constructor + (field + name: (identifier) @function + value: (function_definition))) + +(function_call + name: [ + (identifier) @function.call + (dot_index_expression + field: (identifier) @function.call) + (method_index_expression + method: (identifier) @function.method.call) + ]) + +; --- PICO-8 builtin globals --- + +(function_call + (identifier) @function.builtin + (#any-of? @function.builtin + ; system + "load" "save" "ls" "run" "stop" "assert" "reset" "info" "flip" "printh" + "time" "t" "stat" "extcmd" "holdframe" "_set_fps" + ; graphics + "clip" "pset" "pget" "sget" "sset" "fget" "fset" "print" "cursor" + "color" "cls" "camera" "circ" "circfill" "oval" "ovalfill" "line" + "rect" "rectfill" "rrect" "rrectfill" "pal" "palt" "spr" "sspr" "fillp" + ; tables + "add" "del" "deli" "count" "all" "foreach" "pairs" "ipairs" "next" + ; input + "btn" "btnp" + ; audio + "sfx" "music" + ; map + "mget" "mset" "map" "tline" + ; memory + "peek" "poke" "peek2" "poke2" "peek4" "poke4" "memcpy" "reload" + "cstore" "memset" + ; math + "max" "min" "mid" "flr" "ceil" "cos" "sin" "atan2" "sqrt" "abs" + "rnd" "srand" + ; bitwise (named forms — operator forms covered by @operator) + "band" "bor" "bxor" "bnot" "shl" "shr" "lshr" "rotl" "rotr" + ; custom menu + "menuitem" + ; strings / conversion + "tostr" "tonum" "chr" "ord" "sub" "split" "type" + ; cart data + "cartdata" "dget" "dset" + ; metatables + "setmetatable" "getmetatable" "rawset" "rawget" "rawequal" "rawlen" + ; coroutines + "cocreate" "coresume" "costatus" "yield" + ; error + "error" "pcall" "xpcall")) + +; --- Misc --- + +(comment) @comment +(hash_bang_line) @comment.documentation +(number) @number +(string) @string +(escape_sequence) @string.escape diff --git a/languages/pico-8-lua/indents.scm b/languages/pico-8-lua/indents.scm new file mode 100644 index 0000000..b8d2f9c --- /dev/null +++ b/languages/pico-8-lua/indents.scm @@ -0,0 +1,20 @@ +; Indent inside any block-bearing construct. +(do_statement) @indent +(while_statement) @indent +(repeat_statement) @indent +(for_statement) @indent +(if_statement) @indent +(elseif_statement) @indent +(else_statement) @indent +(function_declaration) @indent +(function_definition) @indent +(table_constructor) @indent +(parenthesized_expression) @indent +(arguments) @indent + +; The closing keywords/brackets sit at the parent's indent level. +"end" @end +"until" @end +"}" @end +")" @end +"]" @end diff --git a/languages/pico-8-lua/injections.scm b/languages/pico-8-lua/injections.scm new file mode 100644 index 0000000..a96d624 --- /dev/null +++ b/languages/pico-8-lua/injections.scm @@ -0,0 +1,2 @@ +; ( reserved for future use — e.g. injecting hex blob content into peek/poke +; string literals, or shader code in spr() comments ) diff --git a/languages/pico-8-lua/outline.scm b/languages/pico-8-lua/outline.scm new file mode 100644 index 0000000..38d556a --- /dev/null +++ b/languages/pico-8-lua/outline.scm @@ -0,0 +1,12 @@ +; Top-level functions appear in the outline. +(function_declaration + "function" @context + name: (_) @name + parameters: (parameters) @context.extra) @item + +; Local functions: local function foo() +(declaration + (function_declaration + "function" @context + name: (identifier) @name + parameters: (parameters) @context.extra)) @item diff --git a/package.json b/package.json index 8951149..3fca050 100644 --- a/package.json +++ b/package.json @@ -1,15 +1,8 @@ { - "name": "tree-sitter-p8-cart", - "version": "0.0.1", - "description": "tree-sitter grammar for the PICO-8 .p8 cartridge text format", - "main": "bindings/node", - "types": "bindings/node", - "keywords": [ - "tree-sitter", - "parser", - "pico-8", - "pico8" - ], + "name": "zed-p8-workspace", + "version": "0.0.2", + "private": true, + "description": "Workspace root for the zed-p8 extension; hosts tree-sitter-cli for the grammars under grammars/", "license": "0BSD", "devDependencies": { "tree-sitter-cli": "^0.24.7"