diff --git a/build.rs b/build.rs index 60ac10eb75..8497ed6327 100644 --- a/build.rs +++ b/build.rs @@ -203,6 +203,11 @@ fn main() { src_dir: "vendored_parsers/tree-sitter-json-src", extra_files: vec![], }, + TreeSitterParser { + name: "tree-sitter-jsonnet", + src_dir: "vendored_parsers/tree-sitter-jsonnet-src", + extra_files: vec!["scanner.c"], + }, TreeSitterParser { name: "tree-sitter-julia", src_dir: "vendored_parsers/tree-sitter-julia-src", diff --git a/sample_files/compare.expected b/sample_files/compare.expected index 5b095b2832..4d5da52344 100644 --- a/sample_files/compare.expected +++ b/sample_files/compare.expected @@ -118,6 +118,9 @@ b9f8e04d42f4c88b3514d31743e17297 - sample_files/json_before.json sample_files/json_after.json 79d34d1bbb670bb702f6ea75ff759fa5 - +sample_files/jsonnet_before.jsonnet sample_files/jsonnet_after.jsonnet +ac7d694beebb1de40bf3c4455c15d894 - + sample_files/jsx_before.jsx sample_files/jsx_after.jsx 908a1637b237cd7763948b7abeb95325 - diff --git a/sample_files/jsonnet_after.jsonnet b/sample_files/jsonnet_after.jsonnet new file mode 100644 index 0000000000..4761aa33a9 --- /dev/null +++ b/sample_files/jsonnet_after.jsonnet @@ -0,0 +1,6 @@ +{ + local func(arg) = arg, + foo: [2, 3, 4, 5], + zab: 'testing', + woo: ['foobar'], +} diff --git a/sample_files/jsonnet_before.jsonnet b/sample_files/jsonnet_before.jsonnet new file mode 100644 index 0000000000..18ee275bcd --- /dev/null +++ b/sample_files/jsonnet_before.jsonnet @@ -0,0 +1,5 @@ +{ + func(arg): arg, + foo: [1, 2, 3, 4], + bar: 'testing', +} diff --git a/src/parse/guess_language.rs b/src/parse/guess_language.rs index 99e389a61d..5aacd8496a 100644 --- a/src/parse/guess_language.rs +++ b/src/parse/guess_language.rs @@ -46,6 +46,7 @@ pub(crate) enum Language { JavaScript, JavascriptJsx, Json, + Jsonnet, Julia, Kotlin, LaTeX, @@ -137,6 +138,7 @@ pub(crate) fn language_name(language: Language) -> &'static str { JavaScript => "JavaScript", JavascriptJsx => "JavaScript JSX", Json => "JSON", + Jsonnet => "Jsonnet", Julia => "Julia", Kotlin => "Kotlin", LaTeX => "LaTeX", @@ -297,6 +299,7 @@ pub(crate) fn language_globs(language: Language) -> Vec { "composer.lock", "mcmod.info", ], + Jsonnet => &["*.jsonnet", "*.libsonnet"], JavascriptJsx => &["*.jsx"], Julia => &["*.jl"], Kotlin => &["*.kt", "*.ktm", "*.kts"], diff --git a/src/parse/tree_sitter_parser.rs b/src/parse/tree_sitter_parser.rs index 39b0af24b9..8dfcfd1c2f 100644 --- a/src/parse/tree_sitter_parser.rs +++ b/src/parse/tree_sitter_parser.rs @@ -87,6 +87,7 @@ extern "C" { fn tree_sitter_java() -> ts::Language; fn tree_sitter_javascript() -> ts::Language; fn tree_sitter_json() -> ts::Language; + fn tree_sitter_jsonnet() -> ts::Language; fn tree_sitter_julia() -> ts::Language; fn tree_sitter_kotlin() -> ts::Language; fn tree_sitter_latex() -> ts::Language; @@ -622,6 +623,20 @@ pub(crate) fn from_language(language: guess::Language) -> TreeSitterConfig { sub_languages: vec![], } } + Jsonnet => { + let language = unsafe { tree_sitter_jsonnet() }; + TreeSitterConfig { + language, + atom_nodes: vec!["string"].into_iter().collect(), + delimiter_tokens: vec![("{", "}"), ("[", "]"), ("(", ")")], + highlight_query: ts::Query::new( + language, + include_str!("../../vendored_parsers/highlights/jsonnet.scm"), + ) + .unwrap(), + sub_languages: vec![], + } + } Julia => { let language = unsafe { tree_sitter_julia() }; TreeSitterConfig { diff --git a/vendored_parsers/highlights/jsonnet.scm b/vendored_parsers/highlights/jsonnet.scm new file mode 120000 index 0000000000..d846144e10 --- /dev/null +++ b/vendored_parsers/highlights/jsonnet.scm @@ -0,0 +1 @@ +../tree-sitter-jsonnet/queries/highlights.scm \ No newline at end of file diff --git a/vendored_parsers/tree-sitter-jsonnet-src b/vendored_parsers/tree-sitter-jsonnet-src new file mode 120000 index 0000000000..d92e985408 --- /dev/null +++ b/vendored_parsers/tree-sitter-jsonnet-src @@ -0,0 +1 @@ +tree-sitter-jsonnet/src \ No newline at end of file diff --git a/vendored_parsers/tree-sitter-jsonnet/.gitignore b/vendored_parsers/tree-sitter-jsonnet/.gitignore new file mode 100644 index 0000000000..18ca5b037d --- /dev/null +++ b/vendored_parsers/tree-sitter-jsonnet/.gitignore @@ -0,0 +1,5 @@ +Cargo.lock +node_modules +build +package-lock.json +/target/ diff --git a/vendored_parsers/tree-sitter-jsonnet/Cargo.toml b/vendored_parsers/tree-sitter-jsonnet/Cargo.toml new file mode 100644 index 0000000000..e19f3c520e --- /dev/null +++ b/vendored_parsers/tree-sitter-jsonnet/Cargo.toml @@ -0,0 +1,26 @@ +[package] +name = "tree-sitter-jsonnet" +description = "jsonnet grammar for the tree-sitter parsing library" +version = "0.0.1" +keywords = ["incremental", "parsing", "jsonnet"] +categories = ["parsing", "text-editors"] +repository = "https://github.com/tree-sitter/tree-sitter-jsonnet" +edition = "2018" +license = "MIT" + +build = "bindings/rust/build.rs" +include = [ + "bindings/rust/*", + "grammar.js", + "queries/*", + "src/*", +] + +[lib] +path = "bindings/rust/lib.rs" + +[dependencies] +tree-sitter = "~0.20" + +[build-dependencies] +cc = "1.0" diff --git a/vendored_parsers/tree-sitter-jsonnet/LICENSE b/vendored_parsers/tree-sitter-jsonnet/LICENSE new file mode 100644 index 0000000000..b8a2a7e537 --- /dev/null +++ b/vendored_parsers/tree-sitter-jsonnet/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2022 Sourcegraph + +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/vendored_parsers/tree-sitter-jsonnet/Makefile b/vendored_parsers/tree-sitter-jsonnet/Makefile new file mode 100644 index 0000000000..9cc974c25b --- /dev/null +++ b/vendored_parsers/tree-sitter-jsonnet/Makefile @@ -0,0 +1,10 @@ +ts := tree-sitter + +generate: + ${ts} generate + +test: generate + ${ts} test + +fmt: + npx prettier --tab-width 4 -w grammar.js diff --git a/vendored_parsers/tree-sitter-jsonnet/README.md b/vendored_parsers/tree-sitter-jsonnet/README.md new file mode 100644 index 0000000000..dae501ef78 --- /dev/null +++ b/vendored_parsers/tree-sitter-jsonnet/README.md @@ -0,0 +1,2 @@ +# tree-sitter-jsonnet +tree-sitter grammar for JSONNET diff --git a/vendored_parsers/tree-sitter-jsonnet/binding.gyp b/vendored_parsers/tree-sitter-jsonnet/binding.gyp new file mode 100644 index 0000000000..a3a6d38e59 --- /dev/null +++ b/vendored_parsers/tree-sitter-jsonnet/binding.gyp @@ -0,0 +1,19 @@ +{ + "targets": [ + { + "target_name": "tree_sitter_jsonnet_binding", + "include_dirs": [ + " +#include "nan.h" + +using namespace v8; + +extern "C" TSLanguage * tree_sitter_jsonnet(); + +namespace { + +NAN_METHOD(New) {} + +void Init(Local exports, Local module) { + Local tpl = Nan::New(New); + tpl->SetClassName(Nan::New("Language").ToLocalChecked()); + tpl->InstanceTemplate()->SetInternalFieldCount(1); + + Local constructor = Nan::GetFunction(tpl).ToLocalChecked(); + Local instance = constructor->NewInstance(Nan::GetCurrentContext()).ToLocalChecked(); + Nan::SetInternalFieldPointer(instance, 0, tree_sitter_jsonnet()); + + Nan::Set(instance, Nan::New("name").ToLocalChecked(), Nan::New("jsonnet").ToLocalChecked()); + Nan::Set(module, Nan::New("exports").ToLocalChecked(), instance); +} + +NODE_MODULE(tree_sitter_jsonnet_binding, Init) + +} // namespace diff --git a/vendored_parsers/tree-sitter-jsonnet/bindings/node/index.js b/vendored_parsers/tree-sitter-jsonnet/bindings/node/index.js new file mode 100644 index 0000000000..1a8c5808bf --- /dev/null +++ b/vendored_parsers/tree-sitter-jsonnet/bindings/node/index.js @@ -0,0 +1,19 @@ +try { + module.exports = require("../../build/Release/tree_sitter_jsonnet_binding"); +} catch (error1) { + if (error1.code !== 'MODULE_NOT_FOUND') { + throw error1; + } + try { + module.exports = require("../../build/Debug/tree_sitter_jsonnet_binding"); + } catch (error2) { + if (error2.code !== 'MODULE_NOT_FOUND') { + throw error2; + } + throw error1 + } +} + +try { + module.exports.nodeTypeInfo = require("../../src/node-types.json"); +} catch (_) {} diff --git a/vendored_parsers/tree-sitter-jsonnet/bindings/rust/build.rs b/vendored_parsers/tree-sitter-jsonnet/bindings/rust/build.rs new file mode 100644 index 0000000000..8f87ee6686 --- /dev/null +++ b/vendored_parsers/tree-sitter-jsonnet/bindings/rust/build.rs @@ -0,0 +1,19 @@ +fn main() { + let src_dir = std::path::Path::new("src"); + + let mut c_config = cc::Build::new(); + c_config.include(&src_dir); + c_config + .flag_if_supported("-Wno-unused-parameter") + .flag_if_supported("-Wno-unused-but-set-variable") + .flag_if_supported("-Wno-trigraphs"); + let parser_path = src_dir.join("parser.c"); + c_config.file(&parser_path); + + let scanner_path = src_dir.join("scanner.c"); + c_config.file(&scanner_path); + println!("cargo:rerun-if-changed={}", scanner_path.to_str().unwrap()); + + c_config.compile("parser"); + println!("cargo:rerun-if-changed={}", parser_path.to_str().unwrap()); +} diff --git a/vendored_parsers/tree-sitter-jsonnet/bindings/rust/lib.rs b/vendored_parsers/tree-sitter-jsonnet/bindings/rust/lib.rs new file mode 100644 index 0000000000..1e0eabdfe5 --- /dev/null +++ b/vendored_parsers/tree-sitter-jsonnet/bindings/rust/lib.rs @@ -0,0 +1,52 @@ +//! This crate provides jsonnet language support for the [tree-sitter][] parsing library. +//! +//! Typically, you will use the [language][language func] function to add this language to a +//! tree-sitter [Parser][], and then use the parser to parse some code: +//! +//! ``` +//! let code = ""; +//! let mut parser = tree_sitter::Parser::new(); +//! parser.set_language(tree_sitter_jsonnet::language()).expect("Error loading jsonnet grammar"); +//! let tree = parser.parse(code, None).unwrap(); +//! ``` +//! +//! [Language]: https://docs.rs/tree-sitter/*/tree_sitter/struct.Language.html +//! [language func]: fn.language.html +//! [Parser]: https://docs.rs/tree-sitter/*/tree_sitter/struct.Parser.html +//! [tree-sitter]: https://tree-sitter.github.io/ + +use tree_sitter::Language; + +extern "C" { + fn tree_sitter_jsonnet() -> Language; +} + +/// Get the tree-sitter [Language][] for this grammar. +/// +/// [Language]: https://docs.rs/tree-sitter/*/tree_sitter/struct.Language.html +pub fn language() -> Language { + unsafe { tree_sitter_jsonnet() } +} + +/// The content of the [`node-types.json`][] file for this grammar. +/// +/// [`node-types.json`]: https://tree-sitter.github.io/tree-sitter/using-parsers#static-node-types +pub const NODE_TYPES: &'static str = include_str!("../../src/node-types.json"); + +// Uncomment these to include any queries that this grammar contains + +// pub const HIGHLIGHTS_QUERY: &'static str = include_str!("../../queries/highlights.scm"); +// pub const INJECTIONS_QUERY: &'static str = include_str!("../../queries/injections.scm"); +// pub const LOCALS_QUERY: &'static str = include_str!("../../queries/locals.scm"); +// pub const TAGS_QUERY: &'static str = include_str!("../../queries/tags.scm"); + +#[cfg(test)] +mod tests { + #[test] + fn test_can_load_grammar() { + let mut parser = tree_sitter::Parser::new(); + parser + .set_language(super::language()) + .expect("Error loading jsonnet language"); + } +} diff --git a/vendored_parsers/tree-sitter-jsonnet/examples/doc_1.jsonnet b/vendored_parsers/tree-sitter-jsonnet/examples/doc_1.jsonnet new file mode 100644 index 0000000000..eaabef477b --- /dev/null +++ b/vendored_parsers/tree-sitter-jsonnet/examples/doc_1.jsonnet @@ -0,0 +1,61 @@ +/* +Copyright 2015 Google Inc. All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Define a local function. +// Default arguments are like Python: +local my_function(x, y=10) = x + y; + +// Define a local multiline function. +local multiline_function(x) = + // One can nest locals. + local temp = x * 2; + // Every local ends with a semi-colon. + [temp, temp + 1]; + +local object = { + // A method + my_method(x): x * x, +}; + +{ + // Functions are first class citizens. + call_inline_function: + (function(x) x * x)(5), + + call_multiline_function: multiline_function(4), + + // Using the variable fetches the function, + // the parens call the function. + call: my_function(true), + + // Like python, parameters can be named at + // call time. + named_params: my_function(x=2), + // This allows changing their order + named_params2: my_function(y=3, x=2), + + // object.my_method returns the function, + // which is then called like any other. + call_method1: object.my_method(3), + + standard_lib: + std.join(' ', std.split('foo/bar', '/')), + + len: [ + std.length('hello'), + std.length([1, 2, 3]), + ], +} diff --git a/vendored_parsers/tree-sitter-jsonnet/examples/example.jsonnet b/vendored_parsers/tree-sitter-jsonnet/examples/example.jsonnet new file mode 100644 index 0000000000..ce01362503 --- /dev/null +++ b/vendored_parsers/tree-sitter-jsonnet/examples/example.jsonnet @@ -0,0 +1 @@ +hello diff --git a/vendored_parsers/tree-sitter-jsonnet/examples/syntax.jsonnet b/vendored_parsers/tree-sitter-jsonnet/examples/syntax.jsonnet new file mode 100644 index 0000000000..3b7e36dbc4 --- /dev/null +++ b/vendored_parsers/tree-sitter-jsonnet/examples/syntax.jsonnet @@ -0,0 +1,77 @@ +// Example file with all(?) possible components from the syntax + +local object = { + 'null': null, + 'true': true, + 'false': false, + string: 'string', + number: 5, + array: [ + null, + true, + false, + 'string', + 1.5, + ], + + forloop: [ + i + for i in std.range(0, 9) + ], + + objforloop: { + ['index' + i]: i + for i in std.range(0, 9) + if (i % 2) == 0 // binaryop: multiplicative and equality + }, + + fieldaccess: self.string, + indexing: self.forloop[self.number], + indexing_obj: self.objforloop['index' + '0'], + indexing_slice: self.forloop[2:8:2], + + binaryop_equality: self.string == 'string', + conditional_in_parenthesis: + (if self.binaryop_equality && true // binaryop: AND + then 'condition true' + else 'condition false'), + + local objlocal = false || true, // binaryop: OR + unaryop: !objlocal, + + anonymous_function:: function(arg, default='v') arg + default, + regular_func(arg):: $.string + ' ' + arg, + + assert true : 'assert instide object', + + 'import':: import 'file.json', + 'importstr':: import 'file.txt', + err:: error 'message', +}; + +assert true : 'assert outside object'; + +object + { + fieldaccess_super: super.number, + indexing_super: super.array[2 * 2], // binaryop: multiplicative + + functioncall_1: super.anonymous_function('echo 1'), + + functioncall_2: self.regular_func(arg='echo 2') tailstrict, + + local localfunc(arg) = { + local notarg = 'value', + a: notarg, // not a parameter reference + b: arg, // parameter reference + [arg]: arg, // parameter reference in fieldname + }, + functioncall_3: localfunc('echo 3'), // function reference + + in_super: 'keynotfound' in super, + + array+: ['another item'], + objforloop+: { another: 'item' }, + + ['fieldname_expr' + (5 - object.objforloop.index2)]: 'value', + [if object.string == 'string' then 'conditional_key']: 'value', +} diff --git a/vendored_parsers/tree-sitter-jsonnet/grammar.js b/vendored_parsers/tree-sitter-jsonnet/grammar.js new file mode 100644 index 0000000000..1311205b90 --- /dev/null +++ b/vendored_parsers/tree-sitter-jsonnet/grammar.js @@ -0,0 +1,432 @@ +const PREC = { + // The priorities below are taken from the spec here: + // https://jsonnet.org/ref/spec.html#associativity_precedence + // The order is reversed though: In the spec, '1' means high priority + // but with tree-sitter it means low priority. + application_indexing: 13, + unary: 12, + multiplicative: 11, + additive: 10, + bitshift: 9, + comparison: 8, + equality: 7, + bitand: 6, + bitxor: 5, + bitor: 4, + and: 3, + or: 2, + // This is not in the spec, which is why we go from 2 to 13 above + // while in the spec it is going from 1 to 12. + member: 1, +}; + +module.exports = grammar({ + name: "jsonnet", + extras: ($) => [/\s/, $.comment], + externals: ($) => [$._string_start, $._string_content, $._string_end], + word: ($) => $._ident, + inline: ($) => [$.h, $.objinside], + conflicts: () => [], + + rules: { + document: ($) => $._expr, + + comment: () => + token( + choice( + seq("//", /.*/), + seq("#", /.*/), + seq("/*", /[^*]*\*+([^/*][^*]*\*+)*/, "/"), + ), + ), + + _expr: ($) => + choice( + $.null, + $.true, + $.false, + $.self, + $.dollar, + $.string, + $.number, + $.object, + $.array, + $.forloop, + $.fieldaccess, + $.indexing, + $.fieldaccess_super, + $.indexing_super, + $.functioncall, + $.id, + $.local_bind, + $.conditional, + $.binary, + $.unary, + $.implicit_plus, + $.anonymous_function, + $._assert_expr, + $.import, + $.importstr, + $.error, + $.in_super, + $.parenthesis, + ), + + // Literals + null: () => "null", + true: () => "true", + false: () => "false", + + // Keywords + self: () => "self", + dollar: () => "$", + super: () => "super", + local: () => "local", + tailstrict: () => "tailstrict", + + // Types + number: ($) => $._number, + string: ($) => $._string, + object: ($) => seq("{", optional($.objinside), "}"), + array: ($) => seq("[", commaSep($._expr, true), "]"), + + forloop: ($) => + seq( + "[", + $._expr, + optional(","), + $.forspec, + optional($.compspec), + "]", + ), + + fieldaccess: ($) => + prec( + PREC.application_indexing, + seq($._expr, ".", field("last", $.id)), + ), + + indexing: ($) => + prec( + PREC.application_indexing, + seq( + $._expr, + "[", + optional($._expr), + optional( + seq( + ":", + optional($._expr), + optional(seq(":", optional($._expr))), + ), + ), + "]", + ), + ), + + fieldaccess_super: ($) => seq($.super, ".", $.id), + indexing_super: ($) => seq($.super, "[", $._expr, "]"), + + functioncall: ($) => + prec( + PREC.application_indexing, + seq( + $._expr, + "(", + optional($.args), + ")", + optional($.tailstrict), + ), + ), + + id: ($) => $._ident, + // This use of an intermediate rule for identifiers is to + // overcome some limitations in ocaml-tree-sitter-semgrep. + // Indeed, ocaml-tree-sitter-semgrep can't override terminals (here was id) + // that are also mentioned in the 'word:' directive. + _ident: () => /[_a-zA-Z][_a-zA-Z0-9]*/, + + local_bind: ($) => + prec.right(seq($.local, commaSep1($.bind, false), ";", $._expr)), + + conditional: ($) => + prec.right( + seq( + "if", + field("condition", $._expr), + "then", + field("consequence", $._expr), + optional(seq("else", field("alternative", $._expr))), + ), + ), + + multiplicative: () => choice("*", "/", "%"), + additive: () => choice("+", "-"), + bitshift: () => choice("<<", ">>"), + comparison: () => choice("<", "<=", ">", ">=", "in"), + equality: () => choice("==", "!="), + bitand: () => "&", + bitxor: () => "^", + bitor: () => "|", + and: () => "&&", + or: () => "||", + + binary: ($) => { + const table = [ + [PREC.multiplicative, $.multiplicative], + [PREC.additive, $.additive], + [PREC.bitshift, $.bitshift], + [PREC.comparison, $.comparison], + [PREC.equality, $.equality], + [PREC.bitand, $.bitand], + [PREC.bitxor, $.bitxor], + [PREC.bitor, $.bitor], + [PREC.and, $.and], + [PREC.or, $.or], + ]; + return choice( + ...table.map(([precedence, operator]) => + prec.left( + precedence, + seq( + field("left", $._expr), + field("operator", operator), + field("right", $._expr), + ), + ), + ), + ); + }, + + unary: ($) => + prec( + PREC.unary, + seq(field("operator", $.unaryop), field("argument", $._expr)), + ), + + unaryop: () => choice("-", "+", "!", "~"), + + implicit_plus: ($) => seq($._expr, $.object), + + anonymous_function: ($) => + prec.right( + seq( + "function", + "(", + optional(field("params", $.params)), + ")", + field("body", $._expr), + ), + ), + + _assert_expr: ($) => prec.right(seq($.assert, ";", $._expr)), + + // import string + import: ($) => seq("import", $.string), + + // importstr string + importstr: ($) => seq("importstr", $.string), + + // error expr + error: ($) => prec.right(seq("error", $._expr)), + + in_super: ($) => prec(PREC.comparison, seq($._expr, "in", $.super)), + + parenthesis: ($) => seq("(", $._expr, ")"), + + objinside: ($) => + choice( + // seq($.member, repeat(seq(",", $.member)), optional(",")), + commaSep1($.member, true), + $.objforloop, + ), + + objforloop: ($) => + seq( + repeat(seq($.objlocal, ",")), + $.field, + repeat(seq(",", $.objlocal)), + optional(","), + $.forspec, + optional($.compspec), + ), + + member: ($) => + prec.right(PREC.member, choice($.objlocal, $.assert, $.field)), + + field: ($) => + choice( + seq($.fieldname, optional("+"), $.h, $._expr), + seq( + field("function", $.fieldname), + "(", + optional($.params), + ")", + $.h, + $._expr, + ), + ), + + h: () => choice(":", "::", ":::"), + + objlocal: ($) => seq($.local, $.bind), + + compspec: ($) => repeat1(choice($.forspec, $.ifspec)), + forspec: ($) => seq("for", $.id, "in", $._expr), + ifspec: ($) => seq("if", $._expr), + + fieldname: ($) => + prec.right(choice($.id, $.string, seq("[", $._expr, "]"))), + + // assert in objects + assert: ($) => seq("assert", $._expr, optional(seq(":", $._expr))), + + bind: ($) => + choice( + seq($.id, "=", $._expr), + prec.right( + seq( + field("function", $.id), + "(", + optional(field("params", $.params)), + ")", + "=", + field("body", $._expr), + ), + ), + ), + + args: ($) => + choice( + seq( + $._expr, + repeat(seq(",", $._expr)), + repeat(seq(",", $.named_argument)), + optional(","), + ), + seq( + $.named_argument, + repeat(seq(",", $.named_argument)), + optional(","), + ), + ), + named_argument: ($) => seq($.id, "=", $._expr), + + params: ($) => commaSep1($.param, true), + param: ($) => + seq( + field("identifier", $.id), + optional(seq("=", field("value", $._expr))), + ), + + // COPIED FROM: tree-sitter-json + _number: () => { + const hex_literal = seq(choice("0x", "0X"), /[\da-fA-F]+/); + + const decimal_digits = /\d+/; + const signed_integer = seq( + optional(choice("-", "+")), + decimal_digits, + ); + const exponent_part = seq(choice("e", "E"), signed_integer); + + const binary_literal = seq(choice("0b", "0B"), /[0-1]+/); + + const octal_literal = seq(choice("0o", "0O"), /[0-7]+/); + + const decimal_integer_literal = seq( + optional(choice("-", "+")), + choice("0", seq(/[1-9]/, optional(decimal_digits))), + ); + + const decimal_literal = choice( + seq( + decimal_integer_literal, + ".", + optional(decimal_digits), + optional(exponent_part), + ), + seq(".", decimal_digits, optional(exponent_part)), + seq(decimal_integer_literal, optional(exponent_part)), + ); + + return token( + choice( + hex_literal, + decimal_literal, + binary_literal, + octal_literal, + ), + ); + }, + + _string: ($) => + choice( + // Single Quotes + seq( + optional("@"), + alias($._single, $.string_start), + alias($._single, $.string_end), + ), + seq( + optional("@"), + alias($._single, $.string_start), + alias($._str_single, $.string_content), + alias($._single, $.string_end), + ), + // Double Quotes + seq( + optional("@"), + alias($._double, $.string_start), + alias($._double, $.string_end), + ), + seq( + optional("@"), + alias($._double, $.string_start), + alias($._str_double, $.string_content), + alias($._double, $.string_end), + ), + // ||| Quotes + seq( + optional("@"), + alias($._string_start, $.string_start), + alias($._string_content, $.string_content), + alias($._string_end, $.string_end), + ), + ), + + _single: () => "'", + _double: () => '"', + + _str_double: ($) => + repeat1( + choice( + token.immediate(prec(1, /[^\\"\n]+/)), + $.escape_sequence, + ), + ), + + _str_single: ($) => + repeat1( + choice( + token.immediate(prec(1, /[^\\'\n]+/)), + $.escape_sequence, + ), + ), + + escape_sequence: () => + token.immediate(seq("\\", /(\"|\\|\/|b|f|n|r|t|u)/)), + }, +}); + +function commaSep1(rule, trailing) { + if (trailing) { + return seq(rule, repeat(seq(",", rule)), optional(",")); + } else { + return seq(rule, repeat(seq(",", rule))); + } +} + +function commaSep(rule, trailing) { + return optional(commaSep1(rule, trailing)); +} diff --git a/vendored_parsers/tree-sitter-jsonnet/package.json b/vendored_parsers/tree-sitter-jsonnet/package.json new file mode 100644 index 0000000000..764f9b35a1 --- /dev/null +++ b/vendored_parsers/tree-sitter-jsonnet/package.json @@ -0,0 +1,28 @@ +{ + "name": "tree-sitter-jsonnet", + "version": "0.0.1", + "description": "jsonnet grammar for tree-sitter", + "main": "bindings/node", + "keywords": [ + "parsing", + "incremental" + ], + "dependencies": { + "nan": "^2.12.1" + }, + "devDependencies": { + "tree-sitter-cli": "^0.20.6" + }, + "scripts": { + "test": "tree-sitter test" + }, + "tree-sitter": [ + { + "scope": "source.jsonnet", + "file-types": [ + "jsonnet" + ], + "injection-regex": "jsonnet" + } + ] +} diff --git a/vendored_parsers/tree-sitter-jsonnet/queries/folds.scm b/vendored_parsers/tree-sitter-jsonnet/queries/folds.scm new file mode 100644 index 0000000000..9243ccfde8 --- /dev/null +++ b/vendored_parsers/tree-sitter-jsonnet/queries/folds.scm @@ -0,0 +1,10 @@ +[ + (field) + (object) + (array) + (parenthesis) + (bind) +; (params) +; (args) +; (conditional) +] @fold diff --git a/vendored_parsers/tree-sitter-jsonnet/queries/highlights.scm b/vendored_parsers/tree-sitter-jsonnet/queries/highlights.scm new file mode 100644 index 0000000000..0dbd169e14 --- /dev/null +++ b/vendored_parsers/tree-sitter-jsonnet/queries/highlights.scm @@ -0,0 +1,164 @@ +(id) @variable +(comment) @comment + +; Literals +(null) @constant.builtin +(string) @string +(number) @number +[ + (true) + (false) +] @boolean + +; Keywords +"for" @repeat +"in" @keyword.operator +"function" @keyword.function +[ + "if" + "then" + "else" +] @conditional +[ + (local) + (tailstrict) + "function" + "assert" + "error" +] @keyword + +[ + (dollar) + (self) + (super) +] @variable.builtin +((id) @variable.builtin + (#eq? @variable.builtin "std")) + +; Operators +[ + (multiplicative) + (additive) + (bitshift) + (comparison) + (equality) + (bitand) + (bitxor) + (bitor) + (and) + (or) + (unaryop) +] @operator + +; Punctuation +[ + "[" + "]" + "{" + "}" + "(" + ")" +] @punctuation.bracket + +[ + "." + "," + ";" + ":" +] @punctuation.delimiter + +[ + "::" + ":::" +] @punctuation.special + +(field + (fieldname) "+" @punctuation.special) + +; Imports +[ + (import) + (importstr) +] @include + +; References + +; Make reference same color as parameter +; (may incur performance issues on big files) +; Depends on locals.scm +((id) @parameter.reference + (#is? @parameter.reference parameter)) + +((id) @function.reference + (#is? @function.reference function)) + +((id) @var.reference + (#is? @var.reference var)) +((id) @define + (#is? @var.reference var)) + +; References do not apply to static field IDs +; Workaround for `(#is-not? local)` not supported +(fieldname (id) @field) +(fieldname (string + (string_start) @text.strong + (string_content) @field + (string_end) @text.strong + )) + +; But it does apply if ID in an expression +(fieldname + ("[" + (id) @parameter.reference + "]" + (#is? @parameter.reference parameter))) +(fieldname + ("[" + (id) @define + "]" + (#is? @var.reference var))) + +; Functions +(field + function: (fieldname (id) @function)) +(field + function: (fieldname + (string + (string_start) @text.strong + (string_content) @function + (string_end) @text.strong + ))) +(param + identifier: (id) @parameter) + +(bind (id) @define) +(bind function: (id) @function) + +; Function call +(functioncall + (fieldaccess + last: (id) @function.call + )? + (fieldaccess_super + (id) @function.call + )? + (id)? @function.call + "(" + (args + (named_argument + (id) @parameter + ) + )? + ")" +) + +; Emphasize implicit plus usage +(implicit_plus + (_ "}"? @text.danger) + (object + "{" @text.danger + ) +) + +; ERROR +(ERROR) @error diff --git a/vendored_parsers/tree-sitter-jsonnet/queries/locals.scm b/vendored_parsers/tree-sitter-jsonnet/queries/locals.scm new file mode 100644 index 0000000000..248b031a7b --- /dev/null +++ b/vendored_parsers/tree-sitter-jsonnet/queries/locals.scm @@ -0,0 +1,18 @@ +(parenthesis) @scope +(anonymous_function) @scope +(object) @scope +(field) @scope +(local_bind) @scope + +(field + function: (fieldname (id) @definition.function) + (#set! "definition.function.scope" "parent") +) + +(bind (id) @definition.var) +(bind function: (id) @definition.function) + +(param (id) @definition.parameter) + +(id) @reference +;(fieldname (id) (#is-not? local)) diff --git a/vendored_parsers/tree-sitter-jsonnet/src/grammar.json b/vendored_parsers/tree-sitter-jsonnet/src/grammar.json new file mode 100644 index 0000000000..cea298164f --- /dev/null +++ b/vendored_parsers/tree-sitter-jsonnet/src/grammar.json @@ -0,0 +1,2627 @@ +{ + "name": "jsonnet", + "word": "_ident", + "rules": { + "document": { + "type": "SYMBOL", + "name": "_expr" + }, + "comment": { + "type": "TOKEN", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "//" + }, + { + "type": "PATTERN", + "value": ".*" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "#" + }, + { + "type": "PATTERN", + "value": ".*" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "/*" + }, + { + "type": "PATTERN", + "value": "[^*]*\\*+([^/*][^*]*\\*+)*" + }, + { + "type": "STRING", + "value": "/" + } + ] + } + ] + } + }, + "_expr": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "null" + }, + { + "type": "SYMBOL", + "name": "true" + }, + { + "type": "SYMBOL", + "name": "false" + }, + { + "type": "SYMBOL", + "name": "self" + }, + { + "type": "SYMBOL", + "name": "dollar" + }, + { + "type": "SYMBOL", + "name": "string" + }, + { + "type": "SYMBOL", + "name": "number" + }, + { + "type": "SYMBOL", + "name": "object" + }, + { + "type": "SYMBOL", + "name": "array" + }, + { + "type": "SYMBOL", + "name": "forloop" + }, + { + "type": "SYMBOL", + "name": "fieldaccess" + }, + { + "type": "SYMBOL", + "name": "indexing" + }, + { + "type": "SYMBOL", + "name": "fieldaccess_super" + }, + { + "type": "SYMBOL", + "name": "indexing_super" + }, + { + "type": "SYMBOL", + "name": "functioncall" + }, + { + "type": "SYMBOL", + "name": "id" + }, + { + "type": "SYMBOL", + "name": "local_bind" + }, + { + "type": "SYMBOL", + "name": "conditional" + }, + { + "type": "SYMBOL", + "name": "binary" + }, + { + "type": "SYMBOL", + "name": "unary" + }, + { + "type": "SYMBOL", + "name": "implicit_plus" + }, + { + "type": "SYMBOL", + "name": "anonymous_function" + }, + { + "type": "SYMBOL", + "name": "_assert_expr" + }, + { + "type": "SYMBOL", + "name": "import" + }, + { + "type": "SYMBOL", + "name": "importstr" + }, + { + "type": "SYMBOL", + "name": "error" + }, + { + "type": "SYMBOL", + "name": "in_super" + }, + { + "type": "SYMBOL", + "name": "parenthesis" + } + ] + }, + "null": { + "type": "STRING", + "value": "null" + }, + "true": { + "type": "STRING", + "value": "true" + }, + "false": { + "type": "STRING", + "value": "false" + }, + "self": { + "type": "STRING", + "value": "self" + }, + "dollar": { + "type": "STRING", + "value": "$" + }, + "super": { + "type": "STRING", + "value": "super" + }, + "local": { + "type": "STRING", + "value": "local" + }, + "tailstrict": { + "type": "STRING", + "value": "tailstrict" + }, + "number": { + "type": "SYMBOL", + "name": "_number" + }, + "string": { + "type": "SYMBOL", + "name": "_string" + }, + "object": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "{" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "objinside" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": "}" + } + ] + }, + "array": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "[" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "_expr" + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "_expr" + } + ] + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": "]" + } + ] + }, + "forloop": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "[" + }, + { + "type": "SYMBOL", + "name": "_expr" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "SYMBOL", + "name": "forspec" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "compspec" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": "]" + } + ] + }, + "fieldaccess": { + "type": "PREC", + "value": 13, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "_expr" + }, + { + "type": "STRING", + "value": "." + }, + { + "type": "FIELD", + "name": "last", + "content": { + "type": "SYMBOL", + "name": "id" + } + } + ] + } + }, + "indexing": { + "type": "PREC", + "value": 13, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "_expr" + }, + { + "type": "STRING", + "value": "[" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_expr" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": ":" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_expr" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": ":" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_expr" + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": "]" + } + ] + } + }, + "fieldaccess_super": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "super" + }, + { + "type": "STRING", + "value": "." + }, + { + "type": "SYMBOL", + "name": "id" + } + ] + }, + "indexing_super": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "super" + }, + { + "type": "STRING", + "value": "[" + }, + { + "type": "SYMBOL", + "name": "_expr" + }, + { + "type": "STRING", + "value": "]" + } + ] + }, + "functioncall": { + "type": "PREC", + "value": 13, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "_expr" + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "args" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": ")" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "tailstrict" + }, + { + "type": "BLANK" + } + ] + } + ] + } + }, + "id": { + "type": "SYMBOL", + "name": "_ident" + }, + "_ident": { + "type": "PATTERN", + "value": "[_a-zA-Z][_a-zA-Z0-9]*" + }, + "local_bind": { + "type": "PREC_RIGHT", + "value": 0, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "local" + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "bind" + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "bind" + } + ] + } + } + ] + }, + { + "type": "STRING", + "value": ";" + }, + { + "type": "SYMBOL", + "name": "_expr" + } + ] + } + }, + "conditional": { + "type": "PREC_RIGHT", + "value": 0, + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "if" + }, + { + "type": "FIELD", + "name": "condition", + "content": { + "type": "SYMBOL", + "name": "_expr" + } + }, + { + "type": "STRING", + "value": "then" + }, + { + "type": "FIELD", + "name": "consequence", + "content": { + "type": "SYMBOL", + "name": "_expr" + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "else" + }, + { + "type": "FIELD", + "name": "alternative", + "content": { + "type": "SYMBOL", + "name": "_expr" + } + } + ] + }, + { + "type": "BLANK" + } + ] + } + ] + } + }, + "multiplicative": { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "*" + }, + { + "type": "STRING", + "value": "/" + }, + { + "type": "STRING", + "value": "%" + } + ] + }, + "additive": { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "+" + }, + { + "type": "STRING", + "value": "-" + } + ] + }, + "bitshift": { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "<<" + }, + { + "type": "STRING", + "value": ">>" + } + ] + }, + "comparison": { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "<" + }, + { + "type": "STRING", + "value": "<=" + }, + { + "type": "STRING", + "value": ">" + }, + { + "type": "STRING", + "value": ">=" + }, + { + "type": "STRING", + "value": "in" + } + ] + }, + "equality": { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "==" + }, + { + "type": "STRING", + "value": "!=" + } + ] + }, + "bitand": { + "type": "STRING", + "value": "&" + }, + "bitxor": { + "type": "STRING", + "value": "^" + }, + "bitor": { + "type": "STRING", + "value": "|" + }, + "and": { + "type": "STRING", + "value": "&&" + }, + "or": { + "type": "STRING", + "value": "||" + }, + "binary": { + "type": "CHOICE", + "members": [ + { + "type": "PREC_LEFT", + "value": 11, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "_expr" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "SYMBOL", + "name": "multiplicative" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "_expr" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 10, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "_expr" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "SYMBOL", + "name": "additive" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "_expr" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 9, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "_expr" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "SYMBOL", + "name": "bitshift" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "_expr" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 8, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "_expr" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "SYMBOL", + "name": "comparison" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "_expr" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 7, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "_expr" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "SYMBOL", + "name": "equality" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "_expr" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 6, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "_expr" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "SYMBOL", + "name": "bitand" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "_expr" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 5, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "_expr" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "SYMBOL", + "name": "bitxor" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "_expr" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 4, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "_expr" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "SYMBOL", + "name": "bitor" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "_expr" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 3, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "_expr" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "SYMBOL", + "name": "and" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "_expr" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 2, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "_expr" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "SYMBOL", + "name": "or" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "_expr" + } + } + ] + } + } + ] + }, + "unary": { + "type": "PREC", + "value": 12, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "SYMBOL", + "name": "unaryop" + } + }, + { + "type": "FIELD", + "name": "argument", + "content": { + "type": "SYMBOL", + "name": "_expr" + } + } + ] + } + }, + "unaryop": { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "-" + }, + { + "type": "STRING", + "value": "+" + }, + { + "type": "STRING", + "value": "!" + }, + { + "type": "STRING", + "value": "~" + } + ] + }, + "implicit_plus": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "_expr" + }, + { + "type": "SYMBOL", + "name": "object" + } + ] + }, + "anonymous_function": { + "type": "PREC_RIGHT", + "value": 0, + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "function" + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "FIELD", + "name": "params", + "content": { + "type": "SYMBOL", + "name": "params" + } + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": ")" + }, + { + "type": "FIELD", + "name": "body", + "content": { + "type": "SYMBOL", + "name": "_expr" + } + } + ] + } + }, + "_assert_expr": { + "type": "PREC_RIGHT", + "value": 0, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "assert" + }, + { + "type": "STRING", + "value": ";" + }, + { + "type": "SYMBOL", + "name": "_expr" + } + ] + } + }, + "import": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "import" + }, + { + "type": "SYMBOL", + "name": "string" + } + ] + }, + "importstr": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "importstr" + }, + { + "type": "SYMBOL", + "name": "string" + } + ] + }, + "error": { + "type": "PREC_RIGHT", + "value": 0, + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "error" + }, + { + "type": "SYMBOL", + "name": "_expr" + } + ] + } + }, + "in_super": { + "type": "PREC", + "value": 8, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "_expr" + }, + { + "type": "STRING", + "value": "in" + }, + { + "type": "SYMBOL", + "name": "super" + } + ] + } + }, + "parenthesis": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "(" + }, + { + "type": "SYMBOL", + "name": "_expr" + }, + { + "type": "STRING", + "value": ")" + } + ] + }, + "objinside": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "member" + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "member" + } + ] + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "SYMBOL", + "name": "objforloop" + } + ] + }, + "objforloop": { + "type": "SEQ", + "members": [ + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "objlocal" + }, + { + "type": "STRING", + "value": "," + } + ] + } + }, + { + "type": "SYMBOL", + "name": "field" + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "objlocal" + } + ] + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "SYMBOL", + "name": "forspec" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "compspec" + }, + { + "type": "BLANK" + } + ] + } + ] + }, + "member": { + "type": "PREC_RIGHT", + "value": 1, + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "objlocal" + }, + { + "type": "SYMBOL", + "name": "assert" + }, + { + "type": "SYMBOL", + "name": "field" + } + ] + } + }, + "field": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "fieldname" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "+" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "SYMBOL", + "name": "h" + }, + { + "type": "SYMBOL", + "name": "_expr" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "function", + "content": { + "type": "SYMBOL", + "name": "fieldname" + } + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "params" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": ")" + }, + { + "type": "SYMBOL", + "name": "h" + }, + { + "type": "SYMBOL", + "name": "_expr" + } + ] + } + ] + }, + "h": { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": ":" + }, + { + "type": "STRING", + "value": "::" + }, + { + "type": "STRING", + "value": ":::" + } + ] + }, + "objlocal": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "local" + }, + { + "type": "SYMBOL", + "name": "bind" + } + ] + }, + "compspec": { + "type": "REPEAT1", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "forspec" + }, + { + "type": "SYMBOL", + "name": "ifspec" + } + ] + } + }, + "forspec": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "for" + }, + { + "type": "SYMBOL", + "name": "id" + }, + { + "type": "STRING", + "value": "in" + }, + { + "type": "SYMBOL", + "name": "_expr" + } + ] + }, + "ifspec": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "if" + }, + { + "type": "SYMBOL", + "name": "_expr" + } + ] + }, + "fieldname": { + "type": "PREC_RIGHT", + "value": 0, + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "id" + }, + { + "type": "SYMBOL", + "name": "string" + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "[" + }, + { + "type": "SYMBOL", + "name": "_expr" + }, + { + "type": "STRING", + "value": "]" + } + ] + } + ] + } + }, + "assert": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "assert" + }, + { + "type": "SYMBOL", + "name": "_expr" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": ":" + }, + { + "type": "SYMBOL", + "name": "_expr" + } + ] + }, + { + "type": "BLANK" + } + ] + } + ] + }, + "bind": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "id" + }, + { + "type": "STRING", + "value": "=" + }, + { + "type": "SYMBOL", + "name": "_expr" + } + ] + }, + { + "type": "PREC_RIGHT", + "value": 0, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "function", + "content": { + "type": "SYMBOL", + "name": "id" + } + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "FIELD", + "name": "params", + "content": { + "type": "SYMBOL", + "name": "params" + } + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": ")" + }, + { + "type": "STRING", + "value": "=" + }, + { + "type": "FIELD", + "name": "body", + "content": { + "type": "SYMBOL", + "name": "_expr" + } + } + ] + } + } + ] + }, + "args": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "_expr" + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "_expr" + } + ] + } + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "named_argument" + } + ] + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "named_argument" + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "named_argument" + } + ] + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "BLANK" + } + ] + } + ] + } + ] + }, + "named_argument": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "id" + }, + { + "type": "STRING", + "value": "=" + }, + { + "type": "SYMBOL", + "name": "_expr" + } + ] + }, + "params": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "param" + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "param" + } + ] + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "BLANK" + } + ] + } + ] + }, + "param": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "identifier", + "content": { + "type": "SYMBOL", + "name": "id" + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "=" + }, + { + "type": "FIELD", + "name": "value", + "content": { + "type": "SYMBOL", + "name": "_expr" + } + } + ] + }, + { + "type": "BLANK" + } + ] + } + ] + }, + "_number": { + "type": "TOKEN", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "0x" + }, + { + "type": "STRING", + "value": "0X" + } + ] + }, + { + "type": "PATTERN", + "value": "[\\da-fA-F]+" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "-" + }, + { + "type": "STRING", + "value": "+" + } + ] + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "0" + }, + { + "type": "SEQ", + "members": [ + { + "type": "PATTERN", + "value": "[1-9]" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "PATTERN", + "value": "\\d+" + }, + { + "type": "BLANK" + } + ] + } + ] + } + ] + } + ] + }, + { + "type": "STRING", + "value": "." + }, + { + "type": "CHOICE", + "members": [ + { + "type": "PATTERN", + "value": "\\d+" + }, + { + "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": "\\d+" + } + ] + } + ] + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "." + }, + { + "type": "PATTERN", + "value": "\\d+" + }, + { + "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": "\\d+" + } + ] + } + ] + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "-" + }, + { + "type": "STRING", + "value": "+" + } + ] + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "0" + }, + { + "type": "SEQ", + "members": [ + { + "type": "PATTERN", + "value": "[1-9]" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "PATTERN", + "value": "\\d+" + }, + { + "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": "\\d+" + } + ] + } + ] + }, + { + "type": "BLANK" + } + ] + } + ] + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "0b" + }, + { + "type": "STRING", + "value": "0B" + } + ] + }, + { + "type": "PATTERN", + "value": "[0-1]+" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "0o" + }, + { + "type": "STRING", + "value": "0O" + } + ] + }, + { + "type": "PATTERN", + "value": "[0-7]+" + } + ] + } + ] + } + }, + "_string": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "@" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_single" + }, + "named": true, + "value": "string_start" + }, + { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_single" + }, + "named": true, + "value": "string_end" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "@" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_single" + }, + "named": true, + "value": "string_start" + }, + { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_str_single" + }, + "named": true, + "value": "string_content" + }, + { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_single" + }, + "named": true, + "value": "string_end" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "@" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_double" + }, + "named": true, + "value": "string_start" + }, + { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_double" + }, + "named": true, + "value": "string_end" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "@" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_double" + }, + "named": true, + "value": "string_start" + }, + { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_str_double" + }, + "named": true, + "value": "string_content" + }, + { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_double" + }, + "named": true, + "value": "string_end" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "@" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_string_start" + }, + "named": true, + "value": "string_start" + }, + { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_string_content" + }, + "named": true, + "value": "string_content" + }, + { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_string_end" + }, + "named": true, + "value": "string_end" + } + ] + } + ] + }, + "_single": { + "type": "STRING", + "value": "'" + }, + "_double": { + "type": "STRING", + "value": "\"" + }, + "_str_double": { + "type": "REPEAT1", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "IMMEDIATE_TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[^\\\\\"\\n]+" + } + } + }, + { + "type": "SYMBOL", + "name": "escape_sequence" + } + ] + } + }, + "_str_single": { + "type": "REPEAT1", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "IMMEDIATE_TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[^\\\\'\\n]+" + } + } + }, + { + "type": "SYMBOL", + "name": "escape_sequence" + } + ] + } + }, + "escape_sequence": { + "type": "IMMEDIATE_TOKEN", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "\\" + }, + { + "type": "PATTERN", + "value": "(\\\"|\\\\|\\/|b|f|n|r|t|u)" + } + ] + } + } + }, + "extras": [ + { + "type": "PATTERN", + "value": "\\s" + }, + { + "type": "SYMBOL", + "name": "comment" + } + ], + "conflicts": [], + "precedences": [], + "externals": [ + { + "type": "SYMBOL", + "name": "_string_start" + }, + { + "type": "SYMBOL", + "name": "_string_content" + }, + { + "type": "SYMBOL", + "name": "_string_end" + } + ], + "inline": [ + "h", + "objinside" + ], + "supertypes": [] +} + diff --git a/vendored_parsers/tree-sitter-jsonnet/src/node-types.json b/vendored_parsers/tree-sitter-jsonnet/src/node-types.json new file mode 100644 index 0000000000..f1d8e11c41 --- /dev/null +++ b/vendored_parsers/tree-sitter-jsonnet/src/node-types.json @@ -0,0 +1,4226 @@ +[ + { + "type": "additive", + "named": true, + "fields": {} + }, + { + "type": "anonymous_function", + "named": true, + "fields": { + "body": { + "multiple": true, + "required": true, + "types": [ + { + "type": ";", + "named": false + }, + { + "type": "anonymous_function", + "named": true + }, + { + "type": "array", + "named": true + }, + { + "type": "assert", + "named": true + }, + { + "type": "binary", + "named": true + }, + { + "type": "conditional", + "named": true + }, + { + "type": "dollar", + "named": true + }, + { + "type": "error", + "named": true + }, + { + "type": "false", + "named": true + }, + { + "type": "fieldaccess", + "named": true + }, + { + "type": "fieldaccess_super", + "named": true + }, + { + "type": "forloop", + "named": true + }, + { + "type": "functioncall", + "named": true + }, + { + "type": "id", + "named": true + }, + { + "type": "implicit_plus", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "importstr", + "named": true + }, + { + "type": "in_super", + "named": true + }, + { + "type": "indexing", + "named": true + }, + { + "type": "indexing_super", + "named": true + }, + { + "type": "local_bind", + "named": true + }, + { + "type": "null", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "object", + "named": true + }, + { + "type": "parenthesis", + "named": true + }, + { + "type": "self", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "true", + "named": true + }, + { + "type": "unary", + "named": true + } + ] + }, + "params": { + "multiple": false, + "required": false, + "types": [ + { + "type": "params", + "named": true + } + ] + } + } + }, + { + "type": "args", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "anonymous_function", + "named": true + }, + { + "type": "array", + "named": true + }, + { + "type": "assert", + "named": true + }, + { + "type": "binary", + "named": true + }, + { + "type": "conditional", + "named": true + }, + { + "type": "dollar", + "named": true + }, + { + "type": "error", + "named": true + }, + { + "type": "false", + "named": true + }, + { + "type": "fieldaccess", + "named": true + }, + { + "type": "fieldaccess_super", + "named": true + }, + { + "type": "forloop", + "named": true + }, + { + "type": "functioncall", + "named": true + }, + { + "type": "id", + "named": true + }, + { + "type": "implicit_plus", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "importstr", + "named": true + }, + { + "type": "in_super", + "named": true + }, + { + "type": "indexing", + "named": true + }, + { + "type": "indexing_super", + "named": true + }, + { + "type": "local_bind", + "named": true + }, + { + "type": "named_argument", + "named": true + }, + { + "type": "null", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "object", + "named": true + }, + { + "type": "parenthesis", + "named": true + }, + { + "type": "self", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "true", + "named": true + }, + { + "type": "unary", + "named": true + } + ] + } + }, + { + "type": "array", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "anonymous_function", + "named": true + }, + { + "type": "array", + "named": true + }, + { + "type": "assert", + "named": true + }, + { + "type": "binary", + "named": true + }, + { + "type": "conditional", + "named": true + }, + { + "type": "dollar", + "named": true + }, + { + "type": "error", + "named": true + }, + { + "type": "false", + "named": true + }, + { + "type": "fieldaccess", + "named": true + }, + { + "type": "fieldaccess_super", + "named": true + }, + { + "type": "forloop", + "named": true + }, + { + "type": "functioncall", + "named": true + }, + { + "type": "id", + "named": true + }, + { + "type": "implicit_plus", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "importstr", + "named": true + }, + { + "type": "in_super", + "named": true + }, + { + "type": "indexing", + "named": true + }, + { + "type": "indexing_super", + "named": true + }, + { + "type": "local_bind", + "named": true + }, + { + "type": "null", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "object", + "named": true + }, + { + "type": "parenthesis", + "named": true + }, + { + "type": "self", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "true", + "named": true + }, + { + "type": "unary", + "named": true + } + ] + } + }, + { + "type": "assert", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "anonymous_function", + "named": true + }, + { + "type": "array", + "named": true + }, + { + "type": "assert", + "named": true + }, + { + "type": "binary", + "named": true + }, + { + "type": "conditional", + "named": true + }, + { + "type": "dollar", + "named": true + }, + { + "type": "error", + "named": true + }, + { + "type": "false", + "named": true + }, + { + "type": "fieldaccess", + "named": true + }, + { + "type": "fieldaccess_super", + "named": true + }, + { + "type": "forloop", + "named": true + }, + { + "type": "functioncall", + "named": true + }, + { + "type": "id", + "named": true + }, + { + "type": "implicit_plus", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "importstr", + "named": true + }, + { + "type": "in_super", + "named": true + }, + { + "type": "indexing", + "named": true + }, + { + "type": "indexing_super", + "named": true + }, + { + "type": "local_bind", + "named": true + }, + { + "type": "null", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "object", + "named": true + }, + { + "type": "parenthesis", + "named": true + }, + { + "type": "self", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "true", + "named": true + }, + { + "type": "unary", + "named": true + } + ] + } + }, + { + "type": "binary", + "named": true, + "fields": { + "left": { + "multiple": true, + "required": true, + "types": [ + { + "type": ";", + "named": false + }, + { + "type": "anonymous_function", + "named": true + }, + { + "type": "array", + "named": true + }, + { + "type": "assert", + "named": true + }, + { + "type": "binary", + "named": true + }, + { + "type": "conditional", + "named": true + }, + { + "type": "dollar", + "named": true + }, + { + "type": "error", + "named": true + }, + { + "type": "false", + "named": true + }, + { + "type": "fieldaccess", + "named": true + }, + { + "type": "fieldaccess_super", + "named": true + }, + { + "type": "forloop", + "named": true + }, + { + "type": "functioncall", + "named": true + }, + { + "type": "id", + "named": true + }, + { + "type": "implicit_plus", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "importstr", + "named": true + }, + { + "type": "in_super", + "named": true + }, + { + "type": "indexing", + "named": true + }, + { + "type": "indexing_super", + "named": true + }, + { + "type": "local_bind", + "named": true + }, + { + "type": "null", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "object", + "named": true + }, + { + "type": "parenthesis", + "named": true + }, + { + "type": "self", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "true", + "named": true + }, + { + "type": "unary", + "named": true + } + ] + }, + "operator": { + "multiple": false, + "required": true, + "types": [ + { + "type": "additive", + "named": true + }, + { + "type": "and", + "named": true + }, + { + "type": "bitand", + "named": true + }, + { + "type": "bitor", + "named": true + }, + { + "type": "bitshift", + "named": true + }, + { + "type": "bitxor", + "named": true + }, + { + "type": "comparison", + "named": true + }, + { + "type": "equality", + "named": true + }, + { + "type": "multiplicative", + "named": true + }, + { + "type": "or", + "named": true + } + ] + }, + "right": { + "multiple": true, + "required": true, + "types": [ + { + "type": ";", + "named": false + }, + { + "type": "anonymous_function", + "named": true + }, + { + "type": "array", + "named": true + }, + { + "type": "assert", + "named": true + }, + { + "type": "binary", + "named": true + }, + { + "type": "conditional", + "named": true + }, + { + "type": "dollar", + "named": true + }, + { + "type": "error", + "named": true + }, + { + "type": "false", + "named": true + }, + { + "type": "fieldaccess", + "named": true + }, + { + "type": "fieldaccess_super", + "named": true + }, + { + "type": "forloop", + "named": true + }, + { + "type": "functioncall", + "named": true + }, + { + "type": "id", + "named": true + }, + { + "type": "implicit_plus", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "importstr", + "named": true + }, + { + "type": "in_super", + "named": true + }, + { + "type": "indexing", + "named": true + }, + { + "type": "indexing_super", + "named": true + }, + { + "type": "local_bind", + "named": true + }, + { + "type": "null", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "object", + "named": true + }, + { + "type": "parenthesis", + "named": true + }, + { + "type": "self", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "true", + "named": true + }, + { + "type": "unary", + "named": true + } + ] + } + } + }, + { + "type": "bind", + "named": true, + "fields": { + "body": { + "multiple": true, + "required": false, + "types": [ + { + "type": ";", + "named": false + }, + { + "type": "anonymous_function", + "named": true + }, + { + "type": "array", + "named": true + }, + { + "type": "assert", + "named": true + }, + { + "type": "binary", + "named": true + }, + { + "type": "conditional", + "named": true + }, + { + "type": "dollar", + "named": true + }, + { + "type": "error", + "named": true + }, + { + "type": "false", + "named": true + }, + { + "type": "fieldaccess", + "named": true + }, + { + "type": "fieldaccess_super", + "named": true + }, + { + "type": "forloop", + "named": true + }, + { + "type": "functioncall", + "named": true + }, + { + "type": "id", + "named": true + }, + { + "type": "implicit_plus", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "importstr", + "named": true + }, + { + "type": "in_super", + "named": true + }, + { + "type": "indexing", + "named": true + }, + { + "type": "indexing_super", + "named": true + }, + { + "type": "local_bind", + "named": true + }, + { + "type": "null", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "object", + "named": true + }, + { + "type": "parenthesis", + "named": true + }, + { + "type": "self", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "true", + "named": true + }, + { + "type": "unary", + "named": true + } + ] + }, + "function": { + "multiple": false, + "required": false, + "types": [ + { + "type": "id", + "named": true + } + ] + }, + "params": { + "multiple": false, + "required": false, + "types": [ + { + "type": "params", + "named": true + } + ] + } + }, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "anonymous_function", + "named": true + }, + { + "type": "array", + "named": true + }, + { + "type": "assert", + "named": true + }, + { + "type": "binary", + "named": true + }, + { + "type": "conditional", + "named": true + }, + { + "type": "dollar", + "named": true + }, + { + "type": "error", + "named": true + }, + { + "type": "false", + "named": true + }, + { + "type": "fieldaccess", + "named": true + }, + { + "type": "fieldaccess_super", + "named": true + }, + { + "type": "forloop", + "named": true + }, + { + "type": "functioncall", + "named": true + }, + { + "type": "id", + "named": true + }, + { + "type": "implicit_plus", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "importstr", + "named": true + }, + { + "type": "in_super", + "named": true + }, + { + "type": "indexing", + "named": true + }, + { + "type": "indexing_super", + "named": true + }, + { + "type": "local_bind", + "named": true + }, + { + "type": "null", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "object", + "named": true + }, + { + "type": "parenthesis", + "named": true + }, + { + "type": "self", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "true", + "named": true + }, + { + "type": "unary", + "named": true + } + ] + } + }, + { + "type": "bitshift", + "named": true, + "fields": {} + }, + { + "type": "comparison", + "named": true, + "fields": {} + }, + { + "type": "compspec", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "forspec", + "named": true + }, + { + "type": "ifspec", + "named": true + } + ] + } + }, + { + "type": "conditional", + "named": true, + "fields": { + "alternative": { + "multiple": true, + "required": false, + "types": [ + { + "type": ";", + "named": false + }, + { + "type": "anonymous_function", + "named": true + }, + { + "type": "array", + "named": true + }, + { + "type": "assert", + "named": true + }, + { + "type": "binary", + "named": true + }, + { + "type": "conditional", + "named": true + }, + { + "type": "dollar", + "named": true + }, + { + "type": "error", + "named": true + }, + { + "type": "false", + "named": true + }, + { + "type": "fieldaccess", + "named": true + }, + { + "type": "fieldaccess_super", + "named": true + }, + { + "type": "forloop", + "named": true + }, + { + "type": "functioncall", + "named": true + }, + { + "type": "id", + "named": true + }, + { + "type": "implicit_plus", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "importstr", + "named": true + }, + { + "type": "in_super", + "named": true + }, + { + "type": "indexing", + "named": true + }, + { + "type": "indexing_super", + "named": true + }, + { + "type": "local_bind", + "named": true + }, + { + "type": "null", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "object", + "named": true + }, + { + "type": "parenthesis", + "named": true + }, + { + "type": "self", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "true", + "named": true + }, + { + "type": "unary", + "named": true + } + ] + }, + "condition": { + "multiple": true, + "required": true, + "types": [ + { + "type": ";", + "named": false + }, + { + "type": "anonymous_function", + "named": true + }, + { + "type": "array", + "named": true + }, + { + "type": "assert", + "named": true + }, + { + "type": "binary", + "named": true + }, + { + "type": "conditional", + "named": true + }, + { + "type": "dollar", + "named": true + }, + { + "type": "error", + "named": true + }, + { + "type": "false", + "named": true + }, + { + "type": "fieldaccess", + "named": true + }, + { + "type": "fieldaccess_super", + "named": true + }, + { + "type": "forloop", + "named": true + }, + { + "type": "functioncall", + "named": true + }, + { + "type": "id", + "named": true + }, + { + "type": "implicit_plus", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "importstr", + "named": true + }, + { + "type": "in_super", + "named": true + }, + { + "type": "indexing", + "named": true + }, + { + "type": "indexing_super", + "named": true + }, + { + "type": "local_bind", + "named": true + }, + { + "type": "null", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "object", + "named": true + }, + { + "type": "parenthesis", + "named": true + }, + { + "type": "self", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "true", + "named": true + }, + { + "type": "unary", + "named": true + } + ] + }, + "consequence": { + "multiple": true, + "required": true, + "types": [ + { + "type": ";", + "named": false + }, + { + "type": "anonymous_function", + "named": true + }, + { + "type": "array", + "named": true + }, + { + "type": "assert", + "named": true + }, + { + "type": "binary", + "named": true + }, + { + "type": "conditional", + "named": true + }, + { + "type": "dollar", + "named": true + }, + { + "type": "error", + "named": true + }, + { + "type": "false", + "named": true + }, + { + "type": "fieldaccess", + "named": true + }, + { + "type": "fieldaccess_super", + "named": true + }, + { + "type": "forloop", + "named": true + }, + { + "type": "functioncall", + "named": true + }, + { + "type": "id", + "named": true + }, + { + "type": "implicit_plus", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "importstr", + "named": true + }, + { + "type": "in_super", + "named": true + }, + { + "type": "indexing", + "named": true + }, + { + "type": "indexing_super", + "named": true + }, + { + "type": "local_bind", + "named": true + }, + { + "type": "null", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "object", + "named": true + }, + { + "type": "parenthesis", + "named": true + }, + { + "type": "self", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "true", + "named": true + }, + { + "type": "unary", + "named": true + } + ] + } + } + }, + { + "type": "document", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "anonymous_function", + "named": true + }, + { + "type": "array", + "named": true + }, + { + "type": "assert", + "named": true + }, + { + "type": "binary", + "named": true + }, + { + "type": "conditional", + "named": true + }, + { + "type": "dollar", + "named": true + }, + { + "type": "error", + "named": true + }, + { + "type": "false", + "named": true + }, + { + "type": "fieldaccess", + "named": true + }, + { + "type": "fieldaccess_super", + "named": true + }, + { + "type": "forloop", + "named": true + }, + { + "type": "functioncall", + "named": true + }, + { + "type": "id", + "named": true + }, + { + "type": "implicit_plus", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "importstr", + "named": true + }, + { + "type": "in_super", + "named": true + }, + { + "type": "indexing", + "named": true + }, + { + "type": "indexing_super", + "named": true + }, + { + "type": "local_bind", + "named": true + }, + { + "type": "null", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "object", + "named": true + }, + { + "type": "parenthesis", + "named": true + }, + { + "type": "self", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "true", + "named": true + }, + { + "type": "unary", + "named": true + } + ] + } + }, + { + "type": "equality", + "named": true, + "fields": {} + }, + { + "type": "error", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "anonymous_function", + "named": true + }, + { + "type": "array", + "named": true + }, + { + "type": "assert", + "named": true + }, + { + "type": "binary", + "named": true + }, + { + "type": "conditional", + "named": true + }, + { + "type": "dollar", + "named": true + }, + { + "type": "error", + "named": true + }, + { + "type": "false", + "named": true + }, + { + "type": "fieldaccess", + "named": true + }, + { + "type": "fieldaccess_super", + "named": true + }, + { + "type": "forloop", + "named": true + }, + { + "type": "functioncall", + "named": true + }, + { + "type": "id", + "named": true + }, + { + "type": "implicit_plus", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "importstr", + "named": true + }, + { + "type": "in_super", + "named": true + }, + { + "type": "indexing", + "named": true + }, + { + "type": "indexing_super", + "named": true + }, + { + "type": "local_bind", + "named": true + }, + { + "type": "null", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "object", + "named": true + }, + { + "type": "parenthesis", + "named": true + }, + { + "type": "self", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "true", + "named": true + }, + { + "type": "unary", + "named": true + } + ] + } + }, + { + "type": "field", + "named": true, + "fields": { + "function": { + "multiple": false, + "required": false, + "types": [ + { + "type": "fieldname", + "named": true + } + ] + } + }, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "anonymous_function", + "named": true + }, + { + "type": "array", + "named": true + }, + { + "type": "assert", + "named": true + }, + { + "type": "binary", + "named": true + }, + { + "type": "conditional", + "named": true + }, + { + "type": "dollar", + "named": true + }, + { + "type": "error", + "named": true + }, + { + "type": "false", + "named": true + }, + { + "type": "fieldaccess", + "named": true + }, + { + "type": "fieldaccess_super", + "named": true + }, + { + "type": "fieldname", + "named": true + }, + { + "type": "forloop", + "named": true + }, + { + "type": "functioncall", + "named": true + }, + { + "type": "id", + "named": true + }, + { + "type": "implicit_plus", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "importstr", + "named": true + }, + { + "type": "in_super", + "named": true + }, + { + "type": "indexing", + "named": true + }, + { + "type": "indexing_super", + "named": true + }, + { + "type": "local_bind", + "named": true + }, + { + "type": "null", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "object", + "named": true + }, + { + "type": "params", + "named": true + }, + { + "type": "parenthesis", + "named": true + }, + { + "type": "self", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "true", + "named": true + }, + { + "type": "unary", + "named": true + } + ] + } + }, + { + "type": "fieldaccess", + "named": true, + "fields": { + "last": { + "multiple": false, + "required": true, + "types": [ + { + "type": "id", + "named": true + } + ] + } + }, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "anonymous_function", + "named": true + }, + { + "type": "array", + "named": true + }, + { + "type": "assert", + "named": true + }, + { + "type": "binary", + "named": true + }, + { + "type": "conditional", + "named": true + }, + { + "type": "dollar", + "named": true + }, + { + "type": "error", + "named": true + }, + { + "type": "false", + "named": true + }, + { + "type": "fieldaccess", + "named": true + }, + { + "type": "fieldaccess_super", + "named": true + }, + { + "type": "forloop", + "named": true + }, + { + "type": "functioncall", + "named": true + }, + { + "type": "id", + "named": true + }, + { + "type": "implicit_plus", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "importstr", + "named": true + }, + { + "type": "in_super", + "named": true + }, + { + "type": "indexing", + "named": true + }, + { + "type": "indexing_super", + "named": true + }, + { + "type": "local_bind", + "named": true + }, + { + "type": "null", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "object", + "named": true + }, + { + "type": "parenthesis", + "named": true + }, + { + "type": "self", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "true", + "named": true + }, + { + "type": "unary", + "named": true + } + ] + } + }, + { + "type": "fieldaccess_super", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "id", + "named": true + }, + { + "type": "super", + "named": true + } + ] + } + }, + { + "type": "fieldname", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "anonymous_function", + "named": true + }, + { + "type": "array", + "named": true + }, + { + "type": "assert", + "named": true + }, + { + "type": "binary", + "named": true + }, + { + "type": "conditional", + "named": true + }, + { + "type": "dollar", + "named": true + }, + { + "type": "error", + "named": true + }, + { + "type": "false", + "named": true + }, + { + "type": "fieldaccess", + "named": true + }, + { + "type": "fieldaccess_super", + "named": true + }, + { + "type": "forloop", + "named": true + }, + { + "type": "functioncall", + "named": true + }, + { + "type": "id", + "named": true + }, + { + "type": "implicit_plus", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "importstr", + "named": true + }, + { + "type": "in_super", + "named": true + }, + { + "type": "indexing", + "named": true + }, + { + "type": "indexing_super", + "named": true + }, + { + "type": "local_bind", + "named": true + }, + { + "type": "null", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "object", + "named": true + }, + { + "type": "parenthesis", + "named": true + }, + { + "type": "self", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "true", + "named": true + }, + { + "type": "unary", + "named": true + } + ] + } + }, + { + "type": "forloop", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "anonymous_function", + "named": true + }, + { + "type": "array", + "named": true + }, + { + "type": "assert", + "named": true + }, + { + "type": "binary", + "named": true + }, + { + "type": "compspec", + "named": true + }, + { + "type": "conditional", + "named": true + }, + { + "type": "dollar", + "named": true + }, + { + "type": "error", + "named": true + }, + { + "type": "false", + "named": true + }, + { + "type": "fieldaccess", + "named": true + }, + { + "type": "fieldaccess_super", + "named": true + }, + { + "type": "forloop", + "named": true + }, + { + "type": "forspec", + "named": true + }, + { + "type": "functioncall", + "named": true + }, + { + "type": "id", + "named": true + }, + { + "type": "implicit_plus", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "importstr", + "named": true + }, + { + "type": "in_super", + "named": true + }, + { + "type": "indexing", + "named": true + }, + { + "type": "indexing_super", + "named": true + }, + { + "type": "local_bind", + "named": true + }, + { + "type": "null", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "object", + "named": true + }, + { + "type": "parenthesis", + "named": true + }, + { + "type": "self", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "true", + "named": true + }, + { + "type": "unary", + "named": true + } + ] + } + }, + { + "type": "forspec", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "anonymous_function", + "named": true + }, + { + "type": "array", + "named": true + }, + { + "type": "assert", + "named": true + }, + { + "type": "binary", + "named": true + }, + { + "type": "conditional", + "named": true + }, + { + "type": "dollar", + "named": true + }, + { + "type": "error", + "named": true + }, + { + "type": "false", + "named": true + }, + { + "type": "fieldaccess", + "named": true + }, + { + "type": "fieldaccess_super", + "named": true + }, + { + "type": "forloop", + "named": true + }, + { + "type": "functioncall", + "named": true + }, + { + "type": "id", + "named": true + }, + { + "type": "implicit_plus", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "importstr", + "named": true + }, + { + "type": "in_super", + "named": true + }, + { + "type": "indexing", + "named": true + }, + { + "type": "indexing_super", + "named": true + }, + { + "type": "local_bind", + "named": true + }, + { + "type": "null", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "object", + "named": true + }, + { + "type": "parenthesis", + "named": true + }, + { + "type": "self", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "true", + "named": true + }, + { + "type": "unary", + "named": true + } + ] + } + }, + { + "type": "functioncall", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "anonymous_function", + "named": true + }, + { + "type": "args", + "named": true + }, + { + "type": "array", + "named": true + }, + { + "type": "assert", + "named": true + }, + { + "type": "binary", + "named": true + }, + { + "type": "conditional", + "named": true + }, + { + "type": "dollar", + "named": true + }, + { + "type": "error", + "named": true + }, + { + "type": "false", + "named": true + }, + { + "type": "fieldaccess", + "named": true + }, + { + "type": "fieldaccess_super", + "named": true + }, + { + "type": "forloop", + "named": true + }, + { + "type": "functioncall", + "named": true + }, + { + "type": "id", + "named": true + }, + { + "type": "implicit_plus", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "importstr", + "named": true + }, + { + "type": "in_super", + "named": true + }, + { + "type": "indexing", + "named": true + }, + { + "type": "indexing_super", + "named": true + }, + { + "type": "local_bind", + "named": true + }, + { + "type": "null", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "object", + "named": true + }, + { + "type": "parenthesis", + "named": true + }, + { + "type": "self", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "tailstrict", + "named": true + }, + { + "type": "true", + "named": true + }, + { + "type": "unary", + "named": true + } + ] + } + }, + { + "type": "id", + "named": true, + "fields": {} + }, + { + "type": "ifspec", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "anonymous_function", + "named": true + }, + { + "type": "array", + "named": true + }, + { + "type": "assert", + "named": true + }, + { + "type": "binary", + "named": true + }, + { + "type": "conditional", + "named": true + }, + { + "type": "dollar", + "named": true + }, + { + "type": "error", + "named": true + }, + { + "type": "false", + "named": true + }, + { + "type": "fieldaccess", + "named": true + }, + { + "type": "fieldaccess_super", + "named": true + }, + { + "type": "forloop", + "named": true + }, + { + "type": "functioncall", + "named": true + }, + { + "type": "id", + "named": true + }, + { + "type": "implicit_plus", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "importstr", + "named": true + }, + { + "type": "in_super", + "named": true + }, + { + "type": "indexing", + "named": true + }, + { + "type": "indexing_super", + "named": true + }, + { + "type": "local_bind", + "named": true + }, + { + "type": "null", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "object", + "named": true + }, + { + "type": "parenthesis", + "named": true + }, + { + "type": "self", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "true", + "named": true + }, + { + "type": "unary", + "named": true + } + ] + } + }, + { + "type": "implicit_plus", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "anonymous_function", + "named": true + }, + { + "type": "array", + "named": true + }, + { + "type": "assert", + "named": true + }, + { + "type": "binary", + "named": true + }, + { + "type": "conditional", + "named": true + }, + { + "type": "dollar", + "named": true + }, + { + "type": "error", + "named": true + }, + { + "type": "false", + "named": true + }, + { + "type": "fieldaccess", + "named": true + }, + { + "type": "fieldaccess_super", + "named": true + }, + { + "type": "forloop", + "named": true + }, + { + "type": "functioncall", + "named": true + }, + { + "type": "id", + "named": true + }, + { + "type": "implicit_plus", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "importstr", + "named": true + }, + { + "type": "in_super", + "named": true + }, + { + "type": "indexing", + "named": true + }, + { + "type": "indexing_super", + "named": true + }, + { + "type": "local_bind", + "named": true + }, + { + "type": "null", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "object", + "named": true + }, + { + "type": "parenthesis", + "named": true + }, + { + "type": "self", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "true", + "named": true + }, + { + "type": "unary", + "named": true + } + ] + } + }, + { + "type": "import", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "string", + "named": true + } + ] + } + }, + { + "type": "importstr", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "string", + "named": true + } + ] + } + }, + { + "type": "in_super", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "anonymous_function", + "named": true + }, + { + "type": "array", + "named": true + }, + { + "type": "assert", + "named": true + }, + { + "type": "binary", + "named": true + }, + { + "type": "conditional", + "named": true + }, + { + "type": "dollar", + "named": true + }, + { + "type": "error", + "named": true + }, + { + "type": "false", + "named": true + }, + { + "type": "fieldaccess", + "named": true + }, + { + "type": "fieldaccess_super", + "named": true + }, + { + "type": "forloop", + "named": true + }, + { + "type": "functioncall", + "named": true + }, + { + "type": "id", + "named": true + }, + { + "type": "implicit_plus", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "importstr", + "named": true + }, + { + "type": "in_super", + "named": true + }, + { + "type": "indexing", + "named": true + }, + { + "type": "indexing_super", + "named": true + }, + { + "type": "local_bind", + "named": true + }, + { + "type": "null", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "object", + "named": true + }, + { + "type": "parenthesis", + "named": true + }, + { + "type": "self", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "super", + "named": true + }, + { + "type": "true", + "named": true + }, + { + "type": "unary", + "named": true + } + ] + } + }, + { + "type": "indexing", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "anonymous_function", + "named": true + }, + { + "type": "array", + "named": true + }, + { + "type": "assert", + "named": true + }, + { + "type": "binary", + "named": true + }, + { + "type": "conditional", + "named": true + }, + { + "type": "dollar", + "named": true + }, + { + "type": "error", + "named": true + }, + { + "type": "false", + "named": true + }, + { + "type": "fieldaccess", + "named": true + }, + { + "type": "fieldaccess_super", + "named": true + }, + { + "type": "forloop", + "named": true + }, + { + "type": "functioncall", + "named": true + }, + { + "type": "id", + "named": true + }, + { + "type": "implicit_plus", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "importstr", + "named": true + }, + { + "type": "in_super", + "named": true + }, + { + "type": "indexing", + "named": true + }, + { + "type": "indexing_super", + "named": true + }, + { + "type": "local_bind", + "named": true + }, + { + "type": "null", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "object", + "named": true + }, + { + "type": "parenthesis", + "named": true + }, + { + "type": "self", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "true", + "named": true + }, + { + "type": "unary", + "named": true + } + ] + } + }, + { + "type": "indexing_super", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "anonymous_function", + "named": true + }, + { + "type": "array", + "named": true + }, + { + "type": "assert", + "named": true + }, + { + "type": "binary", + "named": true + }, + { + "type": "conditional", + "named": true + }, + { + "type": "dollar", + "named": true + }, + { + "type": "error", + "named": true + }, + { + "type": "false", + "named": true + }, + { + "type": "fieldaccess", + "named": true + }, + { + "type": "fieldaccess_super", + "named": true + }, + { + "type": "forloop", + "named": true + }, + { + "type": "functioncall", + "named": true + }, + { + "type": "id", + "named": true + }, + { + "type": "implicit_plus", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "importstr", + "named": true + }, + { + "type": "in_super", + "named": true + }, + { + "type": "indexing", + "named": true + }, + { + "type": "indexing_super", + "named": true + }, + { + "type": "local_bind", + "named": true + }, + { + "type": "null", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "object", + "named": true + }, + { + "type": "parenthesis", + "named": true + }, + { + "type": "self", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "super", + "named": true + }, + { + "type": "true", + "named": true + }, + { + "type": "unary", + "named": true + } + ] + } + }, + { + "type": "local_bind", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "anonymous_function", + "named": true + }, + { + "type": "array", + "named": true + }, + { + "type": "assert", + "named": true + }, + { + "type": "binary", + "named": true + }, + { + "type": "bind", + "named": true + }, + { + "type": "conditional", + "named": true + }, + { + "type": "dollar", + "named": true + }, + { + "type": "error", + "named": true + }, + { + "type": "false", + "named": true + }, + { + "type": "fieldaccess", + "named": true + }, + { + "type": "fieldaccess_super", + "named": true + }, + { + "type": "forloop", + "named": true + }, + { + "type": "functioncall", + "named": true + }, + { + "type": "id", + "named": true + }, + { + "type": "implicit_plus", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "importstr", + "named": true + }, + { + "type": "in_super", + "named": true + }, + { + "type": "indexing", + "named": true + }, + { + "type": "indexing_super", + "named": true + }, + { + "type": "local", + "named": true + }, + { + "type": "local_bind", + "named": true + }, + { + "type": "null", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "object", + "named": true + }, + { + "type": "parenthesis", + "named": true + }, + { + "type": "self", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "true", + "named": true + }, + { + "type": "unary", + "named": true + } + ] + } + }, + { + "type": "member", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "assert", + "named": true + }, + { + "type": "field", + "named": true + }, + { + "type": "objlocal", + "named": true + } + ] + } + }, + { + "type": "multiplicative", + "named": true, + "fields": {} + }, + { + "type": "named_argument", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "anonymous_function", + "named": true + }, + { + "type": "array", + "named": true + }, + { + "type": "assert", + "named": true + }, + { + "type": "binary", + "named": true + }, + { + "type": "conditional", + "named": true + }, + { + "type": "dollar", + "named": true + }, + { + "type": "error", + "named": true + }, + { + "type": "false", + "named": true + }, + { + "type": "fieldaccess", + "named": true + }, + { + "type": "fieldaccess_super", + "named": true + }, + { + "type": "forloop", + "named": true + }, + { + "type": "functioncall", + "named": true + }, + { + "type": "id", + "named": true + }, + { + "type": "implicit_plus", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "importstr", + "named": true + }, + { + "type": "in_super", + "named": true + }, + { + "type": "indexing", + "named": true + }, + { + "type": "indexing_super", + "named": true + }, + { + "type": "local_bind", + "named": true + }, + { + "type": "null", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "object", + "named": true + }, + { + "type": "parenthesis", + "named": true + }, + { + "type": "self", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "true", + "named": true + }, + { + "type": "unary", + "named": true + } + ] + } + }, + { + "type": "number", + "named": true, + "fields": {} + }, + { + "type": "object", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "member", + "named": true + }, + { + "type": "objforloop", + "named": true + } + ] + } + }, + { + "type": "objforloop", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "compspec", + "named": true + }, + { + "type": "field", + "named": true + }, + { + "type": "forspec", + "named": true + }, + { + "type": "objlocal", + "named": true + } + ] + } + }, + { + "type": "objlocal", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "bind", + "named": true + }, + { + "type": "local", + "named": true + } + ] + } + }, + { + "type": "param", + "named": true, + "fields": { + "identifier": { + "multiple": false, + "required": true, + "types": [ + { + "type": "id", + "named": true + } + ] + }, + "value": { + "multiple": true, + "required": false, + "types": [ + { + "type": ";", + "named": false + }, + { + "type": "anonymous_function", + "named": true + }, + { + "type": "array", + "named": true + }, + { + "type": "assert", + "named": true + }, + { + "type": "binary", + "named": true + }, + { + "type": "conditional", + "named": true + }, + { + "type": "dollar", + "named": true + }, + { + "type": "error", + "named": true + }, + { + "type": "false", + "named": true + }, + { + "type": "fieldaccess", + "named": true + }, + { + "type": "fieldaccess_super", + "named": true + }, + { + "type": "forloop", + "named": true + }, + { + "type": "functioncall", + "named": true + }, + { + "type": "id", + "named": true + }, + { + "type": "implicit_plus", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "importstr", + "named": true + }, + { + "type": "in_super", + "named": true + }, + { + "type": "indexing", + "named": true + }, + { + "type": "indexing_super", + "named": true + }, + { + "type": "local_bind", + "named": true + }, + { + "type": "null", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "object", + "named": true + }, + { + "type": "parenthesis", + "named": true + }, + { + "type": "self", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "true", + "named": true + }, + { + "type": "unary", + "named": true + } + ] + } + } + }, + { + "type": "params", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "param", + "named": true + } + ] + } + }, + { + "type": "parenthesis", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "anonymous_function", + "named": true + }, + { + "type": "array", + "named": true + }, + { + "type": "assert", + "named": true + }, + { + "type": "binary", + "named": true + }, + { + "type": "conditional", + "named": true + }, + { + "type": "dollar", + "named": true + }, + { + "type": "error", + "named": true + }, + { + "type": "false", + "named": true + }, + { + "type": "fieldaccess", + "named": true + }, + { + "type": "fieldaccess_super", + "named": true + }, + { + "type": "forloop", + "named": true + }, + { + "type": "functioncall", + "named": true + }, + { + "type": "id", + "named": true + }, + { + "type": "implicit_plus", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "importstr", + "named": true + }, + { + "type": "in_super", + "named": true + }, + { + "type": "indexing", + "named": true + }, + { + "type": "indexing_super", + "named": true + }, + { + "type": "local_bind", + "named": true + }, + { + "type": "null", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "object", + "named": true + }, + { + "type": "parenthesis", + "named": true + }, + { + "type": "self", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "true", + "named": true + }, + { + "type": "unary", + "named": true + } + ] + } + }, + { + "type": "string", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "string_content", + "named": true + }, + { + "type": "string_end", + "named": true + }, + { + "type": "string_start", + "named": true + } + ] + } + }, + { + "type": "string_content", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "escape_sequence", + "named": true + } + ] + } + }, + { + "type": "unary", + "named": true, + "fields": { + "argument": { + "multiple": true, + "required": true, + "types": [ + { + "type": ";", + "named": false + }, + { + "type": "anonymous_function", + "named": true + }, + { + "type": "array", + "named": true + }, + { + "type": "assert", + "named": true + }, + { + "type": "binary", + "named": true + }, + { + "type": "conditional", + "named": true + }, + { + "type": "dollar", + "named": true + }, + { + "type": "error", + "named": true + }, + { + "type": "false", + "named": true + }, + { + "type": "fieldaccess", + "named": true + }, + { + "type": "fieldaccess_super", + "named": true + }, + { + "type": "forloop", + "named": true + }, + { + "type": "functioncall", + "named": true + }, + { + "type": "id", + "named": true + }, + { + "type": "implicit_plus", + "named": true + }, + { + "type": "import", + "named": true + }, + { + "type": "importstr", + "named": true + }, + { + "type": "in_super", + "named": true + }, + { + "type": "indexing", + "named": true + }, + { + "type": "indexing_super", + "named": true + }, + { + "type": "local_bind", + "named": true + }, + { + "type": "null", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "object", + "named": true + }, + { + "type": "parenthesis", + "named": true + }, + { + "type": "self", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "true", + "named": true + }, + { + "type": "unary", + "named": true + } + ] + }, + "operator": { + "multiple": false, + "required": true, + "types": [ + { + "type": "unaryop", + "named": true + } + ] + } + } + }, + { + "type": "unaryop", + "named": true, + "fields": {} + }, + { + "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": true + }, + { + "type": "assert", + "named": false + }, + { + "type": "bitand", + "named": true + }, + { + "type": "bitor", + "named": true + }, + { + "type": "bitxor", + "named": true + }, + { + "type": "comment", + "named": true + }, + { + "type": "dollar", + "named": true + }, + { + "type": "else", + "named": false + }, + { + "type": "error", + "named": false + }, + { + "type": "escape_sequence", + "named": true + }, + { + "type": "false", + "named": true + }, + { + "type": "for", + "named": false + }, + { + "type": "function", + "named": false + }, + { + "type": "if", + "named": false + }, + { + "type": "import", + "named": false + }, + { + "type": "importstr", + "named": false + }, + { + "type": "in", + "named": false + }, + { + "type": "local", + "named": true + }, + { + "type": "null", + "named": true + }, + { + "type": "or", + "named": true + }, + { + "type": "self", + "named": true + }, + { + "type": "string_end", + "named": true + }, + { + "type": "string_start", + "named": true + }, + { + "type": "super", + "named": true + }, + { + "type": "tailstrict", + "named": true + }, + { + "type": "then", + "named": false + }, + { + "type": "true", + "named": true + }, + { + "type": "{", + "named": false + }, + { + "type": "}", + "named": false + }, + { + "type": "~", + "named": false + } +] \ No newline at end of file diff --git a/vendored_parsers/tree-sitter-jsonnet/src/parser.c b/vendored_parsers/tree-sitter-jsonnet/src/parser.c new file mode 100644 index 0000000000..e4145a3c43 --- /dev/null +++ b/vendored_parsers/tree-sitter-jsonnet/src/parser.c @@ -0,0 +1,18991 @@ +#include + +#if defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wmissing-field-initializers" +#endif + +#define LANGUAGE_VERSION 14 +#define STATE_COUNT 386 +#define LARGE_STATE_COUNT 2 +#define SYMBOL_COUNT 120 +#define ALIAS_COUNT 0 +#define TOKEN_COUNT 64 +#define EXTERNAL_TOKEN_COUNT 3 +#define FIELD_COUNT 13 +#define MAX_ALIAS_SEQUENCE_LENGTH 8 +#define PRODUCTION_ID_COUNT 17 + +enum { + sym__ident = 1, + sym_comment = 2, + sym_null = 3, + sym_true = 4, + sym_false = 5, + sym_self = 6, + sym_dollar = 7, + sym_super = 8, + sym_local = 9, + sym_tailstrict = 10, + anon_sym_LBRACE = 11, + anon_sym_RBRACE = 12, + anon_sym_LBRACK = 13, + anon_sym_COMMA = 14, + anon_sym_RBRACK = 15, + anon_sym_DOT = 16, + anon_sym_COLON = 17, + anon_sym_LPAREN = 18, + anon_sym_RPAREN = 19, + anon_sym_SEMI = 20, + anon_sym_if = 21, + anon_sym_then = 22, + anon_sym_else = 23, + anon_sym_STAR = 24, + anon_sym_SLASH = 25, + anon_sym_PERCENT = 26, + anon_sym_PLUS = 27, + anon_sym_DASH = 28, + anon_sym_LT_LT = 29, + anon_sym_GT_GT = 30, + anon_sym_LT = 31, + anon_sym_LT_EQ = 32, + anon_sym_GT = 33, + anon_sym_GT_EQ = 34, + anon_sym_in = 35, + anon_sym_EQ_EQ = 36, + anon_sym_BANG_EQ = 37, + sym_bitand = 38, + sym_bitxor = 39, + sym_bitor = 40, + sym_and = 41, + sym_or = 42, + anon_sym_BANG = 43, + anon_sym_TILDE = 44, + anon_sym_function = 45, + anon_sym_import = 46, + anon_sym_importstr = 47, + anon_sym_error = 48, + anon_sym_COLON_COLON = 49, + anon_sym_COLON_COLON_COLON = 50, + anon_sym_for = 51, + anon_sym_assert = 52, + anon_sym_EQ = 53, + sym__number = 54, + anon_sym_AT = 55, + sym__single = 56, + sym__double = 57, + aux_sym__str_double_token1 = 58, + aux_sym__str_single_token1 = 59, + sym_escape_sequence = 60, + sym__string_start = 61, + sym__string_content = 62, + sym__string_end = 63, + sym_document = 64, + sym__expr = 65, + sym_number = 66, + sym_string = 67, + sym_object = 68, + sym_array = 69, + sym_forloop = 70, + sym_fieldaccess = 71, + sym_indexing = 72, + sym_fieldaccess_super = 73, + sym_indexing_super = 74, + sym_functioncall = 75, + sym_id = 76, + sym_local_bind = 77, + sym_conditional = 78, + sym_multiplicative = 79, + sym_additive = 80, + sym_bitshift = 81, + sym_comparison = 82, + sym_equality = 83, + sym_binary = 84, + sym_unary = 85, + sym_unaryop = 86, + sym_implicit_plus = 87, + sym_anonymous_function = 88, + sym__assert_expr = 89, + sym_import = 90, + sym_importstr = 91, + sym_error = 92, + sym_in_super = 93, + sym_parenthesis = 94, + sym_objforloop = 95, + sym_member = 96, + sym_field = 97, + sym_objlocal = 98, + sym_compspec = 99, + sym_forspec = 100, + sym_ifspec = 101, + sym_fieldname = 102, + sym_assert = 103, + sym_bind = 104, + sym_args = 105, + sym_named_argument = 106, + sym_params = 107, + sym_param = 108, + sym__string = 109, + aux_sym__str_double = 110, + aux_sym__str_single = 111, + aux_sym_array_repeat1 = 112, + aux_sym_local_bind_repeat1 = 113, + aux_sym_objinside_repeat1 = 114, + aux_sym_objforloop_repeat1 = 115, + aux_sym_objforloop_repeat2 = 116, + aux_sym_compspec_repeat1 = 117, + aux_sym_args_repeat1 = 118, + aux_sym_params_repeat1 = 119, +}; + +static const char * const ts_symbol_names[] = { + [ts_builtin_sym_end] = "end", + [sym__ident] = "_ident", + [sym_comment] = "comment", + [sym_null] = "null", + [sym_true] = "true", + [sym_false] = "false", + [sym_self] = "self", + [sym_dollar] = "dollar", + [sym_super] = "super", + [sym_local] = "local", + [sym_tailstrict] = "tailstrict", + [anon_sym_LBRACE] = "{", + [anon_sym_RBRACE] = "}", + [anon_sym_LBRACK] = "[", + [anon_sym_COMMA] = ",", + [anon_sym_RBRACK] = "]", + [anon_sym_DOT] = ".", + [anon_sym_COLON] = ":", + [anon_sym_LPAREN] = "(", + [anon_sym_RPAREN] = ")", + [anon_sym_SEMI] = ";", + [anon_sym_if] = "if", + [anon_sym_then] = "then", + [anon_sym_else] = "else", + [anon_sym_STAR] = "*", + [anon_sym_SLASH] = "/", + [anon_sym_PERCENT] = "%", + [anon_sym_PLUS] = "+", + [anon_sym_DASH] = "-", + [anon_sym_LT_LT] = "<<", + [anon_sym_GT_GT] = ">>", + [anon_sym_LT] = "<", + [anon_sym_LT_EQ] = "<=", + [anon_sym_GT] = ">", + [anon_sym_GT_EQ] = ">=", + [anon_sym_in] = "in", + [anon_sym_EQ_EQ] = "==", + [anon_sym_BANG_EQ] = "!=", + [sym_bitand] = "bitand", + [sym_bitxor] = "bitxor", + [sym_bitor] = "bitor", + [sym_and] = "and", + [sym_or] = "or", + [anon_sym_BANG] = "!", + [anon_sym_TILDE] = "~", + [anon_sym_function] = "function", + [anon_sym_import] = "import", + [anon_sym_importstr] = "importstr", + [anon_sym_error] = "error", + [anon_sym_COLON_COLON] = "::", + [anon_sym_COLON_COLON_COLON] = ":::", + [anon_sym_for] = "for", + [anon_sym_assert] = "assert", + [anon_sym_EQ] = "=", + [sym__number] = "_number", + [anon_sym_AT] = "@", + [sym__single] = "string_start", + [sym__double] = "string_start", + [aux_sym__str_double_token1] = "_str_double_token1", + [aux_sym__str_single_token1] = "_str_single_token1", + [sym_escape_sequence] = "escape_sequence", + [sym__string_start] = "string_start", + [sym__string_content] = "string_content", + [sym__string_end] = "string_end", + [sym_document] = "document", + [sym__expr] = "_expr", + [sym_number] = "number", + [sym_string] = "string", + [sym_object] = "object", + [sym_array] = "array", + [sym_forloop] = "forloop", + [sym_fieldaccess] = "fieldaccess", + [sym_indexing] = "indexing", + [sym_fieldaccess_super] = "fieldaccess_super", + [sym_indexing_super] = "indexing_super", + [sym_functioncall] = "functioncall", + [sym_id] = "id", + [sym_local_bind] = "local_bind", + [sym_conditional] = "conditional", + [sym_multiplicative] = "multiplicative", + [sym_additive] = "additive", + [sym_bitshift] = "bitshift", + [sym_comparison] = "comparison", + [sym_equality] = "equality", + [sym_binary] = "binary", + [sym_unary] = "unary", + [sym_unaryop] = "unaryop", + [sym_implicit_plus] = "implicit_plus", + [sym_anonymous_function] = "anonymous_function", + [sym__assert_expr] = "_assert_expr", + [sym_import] = "import", + [sym_importstr] = "importstr", + [sym_error] = "error", + [sym_in_super] = "in_super", + [sym_parenthesis] = "parenthesis", + [sym_objforloop] = "objforloop", + [sym_member] = "member", + [sym_field] = "field", + [sym_objlocal] = "objlocal", + [sym_compspec] = "compspec", + [sym_forspec] = "forspec", + [sym_ifspec] = "ifspec", + [sym_fieldname] = "fieldname", + [sym_assert] = "assert", + [sym_bind] = "bind", + [sym_args] = "args", + [sym_named_argument] = "named_argument", + [sym_params] = "params", + [sym_param] = "param", + [sym__string] = "_string", + [aux_sym__str_double] = "_str_double", + [aux_sym__str_single] = "_str_single", + [aux_sym_array_repeat1] = "array_repeat1", + [aux_sym_local_bind_repeat1] = "local_bind_repeat1", + [aux_sym_objinside_repeat1] = "objinside_repeat1", + [aux_sym_objforloop_repeat1] = "objforloop_repeat1", + [aux_sym_objforloop_repeat2] = "objforloop_repeat2", + [aux_sym_compspec_repeat1] = "compspec_repeat1", + [aux_sym_args_repeat1] = "args_repeat1", + [aux_sym_params_repeat1] = "params_repeat1", +}; + +static const TSSymbol ts_symbol_map[] = { + [ts_builtin_sym_end] = ts_builtin_sym_end, + [sym__ident] = sym__ident, + [sym_comment] = sym_comment, + [sym_null] = sym_null, + [sym_true] = sym_true, + [sym_false] = sym_false, + [sym_self] = sym_self, + [sym_dollar] = sym_dollar, + [sym_super] = sym_super, + [sym_local] = sym_local, + [sym_tailstrict] = sym_tailstrict, + [anon_sym_LBRACE] = anon_sym_LBRACE, + [anon_sym_RBRACE] = anon_sym_RBRACE, + [anon_sym_LBRACK] = anon_sym_LBRACK, + [anon_sym_COMMA] = anon_sym_COMMA, + [anon_sym_RBRACK] = anon_sym_RBRACK, + [anon_sym_DOT] = anon_sym_DOT, + [anon_sym_COLON] = anon_sym_COLON, + [anon_sym_LPAREN] = anon_sym_LPAREN, + [anon_sym_RPAREN] = anon_sym_RPAREN, + [anon_sym_SEMI] = anon_sym_SEMI, + [anon_sym_if] = anon_sym_if, + [anon_sym_then] = anon_sym_then, + [anon_sym_else] = anon_sym_else, + [anon_sym_STAR] = anon_sym_STAR, + [anon_sym_SLASH] = anon_sym_SLASH, + [anon_sym_PERCENT] = anon_sym_PERCENT, + [anon_sym_PLUS] = anon_sym_PLUS, + [anon_sym_DASH] = anon_sym_DASH, + [anon_sym_LT_LT] = anon_sym_LT_LT, + [anon_sym_GT_GT] = anon_sym_GT_GT, + [anon_sym_LT] = anon_sym_LT, + [anon_sym_LT_EQ] = anon_sym_LT_EQ, + [anon_sym_GT] = anon_sym_GT, + [anon_sym_GT_EQ] = anon_sym_GT_EQ, + [anon_sym_in] = anon_sym_in, + [anon_sym_EQ_EQ] = anon_sym_EQ_EQ, + [anon_sym_BANG_EQ] = anon_sym_BANG_EQ, + [sym_bitand] = sym_bitand, + [sym_bitxor] = sym_bitxor, + [sym_bitor] = sym_bitor, + [sym_and] = sym_and, + [sym_or] = sym_or, + [anon_sym_BANG] = anon_sym_BANG, + [anon_sym_TILDE] = anon_sym_TILDE, + [anon_sym_function] = anon_sym_function, + [anon_sym_import] = anon_sym_import, + [anon_sym_importstr] = anon_sym_importstr, + [anon_sym_error] = anon_sym_error, + [anon_sym_COLON_COLON] = anon_sym_COLON_COLON, + [anon_sym_COLON_COLON_COLON] = anon_sym_COLON_COLON_COLON, + [anon_sym_for] = anon_sym_for, + [anon_sym_assert] = anon_sym_assert, + [anon_sym_EQ] = anon_sym_EQ, + [sym__number] = sym__number, + [anon_sym_AT] = anon_sym_AT, + [sym__single] = sym__string_start, + [sym__double] = sym__string_start, + [aux_sym__str_double_token1] = aux_sym__str_double_token1, + [aux_sym__str_single_token1] = aux_sym__str_single_token1, + [sym_escape_sequence] = sym_escape_sequence, + [sym__string_start] = sym__string_start, + [sym__string_content] = sym__string_content, + [sym__string_end] = sym__string_end, + [sym_document] = sym_document, + [sym__expr] = sym__expr, + [sym_number] = sym_number, + [sym_string] = sym_string, + [sym_object] = sym_object, + [sym_array] = sym_array, + [sym_forloop] = sym_forloop, + [sym_fieldaccess] = sym_fieldaccess, + [sym_indexing] = sym_indexing, + [sym_fieldaccess_super] = sym_fieldaccess_super, + [sym_indexing_super] = sym_indexing_super, + [sym_functioncall] = sym_functioncall, + [sym_id] = sym_id, + [sym_local_bind] = sym_local_bind, + [sym_conditional] = sym_conditional, + [sym_multiplicative] = sym_multiplicative, + [sym_additive] = sym_additive, + [sym_bitshift] = sym_bitshift, + [sym_comparison] = sym_comparison, + [sym_equality] = sym_equality, + [sym_binary] = sym_binary, + [sym_unary] = sym_unary, + [sym_unaryop] = sym_unaryop, + [sym_implicit_plus] = sym_implicit_plus, + [sym_anonymous_function] = sym_anonymous_function, + [sym__assert_expr] = sym__assert_expr, + [sym_import] = sym_import, + [sym_importstr] = sym_importstr, + [sym_error] = sym_error, + [sym_in_super] = sym_in_super, + [sym_parenthesis] = sym_parenthesis, + [sym_objforloop] = sym_objforloop, + [sym_member] = sym_member, + [sym_field] = sym_field, + [sym_objlocal] = sym_objlocal, + [sym_compspec] = sym_compspec, + [sym_forspec] = sym_forspec, + [sym_ifspec] = sym_ifspec, + [sym_fieldname] = sym_fieldname, + [sym_assert] = sym_assert, + [sym_bind] = sym_bind, + [sym_args] = sym_args, + [sym_named_argument] = sym_named_argument, + [sym_params] = sym_params, + [sym_param] = sym_param, + [sym__string] = sym__string, + [aux_sym__str_double] = aux_sym__str_double, + [aux_sym__str_single] = aux_sym__str_single, + [aux_sym_array_repeat1] = aux_sym_array_repeat1, + [aux_sym_local_bind_repeat1] = aux_sym_local_bind_repeat1, + [aux_sym_objinside_repeat1] = aux_sym_objinside_repeat1, + [aux_sym_objforloop_repeat1] = aux_sym_objforloop_repeat1, + [aux_sym_objforloop_repeat2] = aux_sym_objforloop_repeat2, + [aux_sym_compspec_repeat1] = aux_sym_compspec_repeat1, + [aux_sym_args_repeat1] = aux_sym_args_repeat1, + [aux_sym_params_repeat1] = aux_sym_params_repeat1, +}; + +static const TSSymbolMetadata ts_symbol_metadata[] = { + [ts_builtin_sym_end] = { + .visible = false, + .named = true, + }, + [sym__ident] = { + .visible = false, + .named = true, + }, + [sym_comment] = { + .visible = true, + .named = true, + }, + [sym_null] = { + .visible = true, + .named = true, + }, + [sym_true] = { + .visible = true, + .named = true, + }, + [sym_false] = { + .visible = true, + .named = true, + }, + [sym_self] = { + .visible = true, + .named = true, + }, + [sym_dollar] = { + .visible = true, + .named = true, + }, + [sym_super] = { + .visible = true, + .named = true, + }, + [sym_local] = { + .visible = true, + .named = true, + }, + [sym_tailstrict] = { + .visible = true, + .named = true, + }, + [anon_sym_LBRACE] = { + .visible = true, + .named = false, + }, + [anon_sym_RBRACE] = { + .visible = true, + .named = false, + }, + [anon_sym_LBRACK] = { + .visible = true, + .named = false, + }, + [anon_sym_COMMA] = { + .visible = true, + .named = false, + }, + [anon_sym_RBRACK] = { + .visible = true, + .named = false, + }, + [anon_sym_DOT] = { + .visible = true, + .named = false, + }, + [anon_sym_COLON] = { + .visible = true, + .named = false, + }, + [anon_sym_LPAREN] = { + .visible = true, + .named = false, + }, + [anon_sym_RPAREN] = { + .visible = true, + .named = false, + }, + [anon_sym_SEMI] = { + .visible = true, + .named = false, + }, + [anon_sym_if] = { + .visible = true, + .named = false, + }, + [anon_sym_then] = { + .visible = true, + .named = false, + }, + [anon_sym_else] = { + .visible = true, + .named = false, + }, + [anon_sym_STAR] = { + .visible = true, + .named = false, + }, + [anon_sym_SLASH] = { + .visible = true, + .named = false, + }, + [anon_sym_PERCENT] = { + .visible = true, + .named = false, + }, + [anon_sym_PLUS] = { + .visible = true, + .named = false, + }, + [anon_sym_DASH] = { + .visible = true, + .named = false, + }, + [anon_sym_LT_LT] = { + .visible = true, + .named = false, + }, + [anon_sym_GT_GT] = { + .visible = true, + .named = false, + }, + [anon_sym_LT] = { + .visible = true, + .named = false, + }, + [anon_sym_LT_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_GT] = { + .visible = true, + .named = false, + }, + [anon_sym_GT_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_in] = { + .visible = true, + .named = false, + }, + [anon_sym_EQ_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_BANG_EQ] = { + .visible = true, + .named = false, + }, + [sym_bitand] = { + .visible = true, + .named = true, + }, + [sym_bitxor] = { + .visible = true, + .named = true, + }, + [sym_bitor] = { + .visible = true, + .named = true, + }, + [sym_and] = { + .visible = true, + .named = true, + }, + [sym_or] = { + .visible = true, + .named = true, + }, + [anon_sym_BANG] = { + .visible = true, + .named = false, + }, + [anon_sym_TILDE] = { + .visible = true, + .named = false, + }, + [anon_sym_function] = { + .visible = true, + .named = false, + }, + [anon_sym_import] = { + .visible = true, + .named = false, + }, + [anon_sym_importstr] = { + .visible = true, + .named = false, + }, + [anon_sym_error] = { + .visible = true, + .named = false, + }, + [anon_sym_COLON_COLON] = { + .visible = true, + .named = false, + }, + [anon_sym_COLON_COLON_COLON] = { + .visible = true, + .named = false, + }, + [anon_sym_for] = { + .visible = true, + .named = false, + }, + [anon_sym_assert] = { + .visible = true, + .named = false, + }, + [anon_sym_EQ] = { + .visible = true, + .named = false, + }, + [sym__number] = { + .visible = false, + .named = true, + }, + [anon_sym_AT] = { + .visible = true, + .named = false, + }, + [sym__single] = { + .visible = true, + .named = true, + }, + [sym__double] = { + .visible = true, + .named = true, + }, + [aux_sym__str_double_token1] = { + .visible = false, + .named = false, + }, + [aux_sym__str_single_token1] = { + .visible = false, + .named = false, + }, + [sym_escape_sequence] = { + .visible = true, + .named = true, + }, + [sym__string_start] = { + .visible = true, + .named = true, + }, + [sym__string_content] = { + .visible = true, + .named = true, + }, + [sym__string_end] = { + .visible = true, + .named = true, + }, + [sym_document] = { + .visible = true, + .named = true, + }, + [sym__expr] = { + .visible = false, + .named = true, + }, + [sym_number] = { + .visible = true, + .named = true, + }, + [sym_string] = { + .visible = true, + .named = true, + }, + [sym_object] = { + .visible = true, + .named = true, + }, + [sym_array] = { + .visible = true, + .named = true, + }, + [sym_forloop] = { + .visible = true, + .named = true, + }, + [sym_fieldaccess] = { + .visible = true, + .named = true, + }, + [sym_indexing] = { + .visible = true, + .named = true, + }, + [sym_fieldaccess_super] = { + .visible = true, + .named = true, + }, + [sym_indexing_super] = { + .visible = true, + .named = true, + }, + [sym_functioncall] = { + .visible = true, + .named = true, + }, + [sym_id] = { + .visible = true, + .named = true, + }, + [sym_local_bind] = { + .visible = true, + .named = true, + }, + [sym_conditional] = { + .visible = true, + .named = true, + }, + [sym_multiplicative] = { + .visible = true, + .named = true, + }, + [sym_additive] = { + .visible = true, + .named = true, + }, + [sym_bitshift] = { + .visible = true, + .named = true, + }, + [sym_comparison] = { + .visible = true, + .named = true, + }, + [sym_equality] = { + .visible = true, + .named = true, + }, + [sym_binary] = { + .visible = true, + .named = true, + }, + [sym_unary] = { + .visible = true, + .named = true, + }, + [sym_unaryop] = { + .visible = true, + .named = true, + }, + [sym_implicit_plus] = { + .visible = true, + .named = true, + }, + [sym_anonymous_function] = { + .visible = true, + .named = true, + }, + [sym__assert_expr] = { + .visible = false, + .named = true, + }, + [sym_import] = { + .visible = true, + .named = true, + }, + [sym_importstr] = { + .visible = true, + .named = true, + }, + [sym_error] = { + .visible = true, + .named = true, + }, + [sym_in_super] = { + .visible = true, + .named = true, + }, + [sym_parenthesis] = { + .visible = true, + .named = true, + }, + [sym_objforloop] = { + .visible = true, + .named = true, + }, + [sym_member] = { + .visible = true, + .named = true, + }, + [sym_field] = { + .visible = true, + .named = true, + }, + [sym_objlocal] = { + .visible = true, + .named = true, + }, + [sym_compspec] = { + .visible = true, + .named = true, + }, + [sym_forspec] = { + .visible = true, + .named = true, + }, + [sym_ifspec] = { + .visible = true, + .named = true, + }, + [sym_fieldname] = { + .visible = true, + .named = true, + }, + [sym_assert] = { + .visible = true, + .named = true, + }, + [sym_bind] = { + .visible = true, + .named = true, + }, + [sym_args] = { + .visible = true, + .named = true, + }, + [sym_named_argument] = { + .visible = true, + .named = true, + }, + [sym_params] = { + .visible = true, + .named = true, + }, + [sym_param] = { + .visible = true, + .named = true, + }, + [sym__string] = { + .visible = false, + .named = true, + }, + [aux_sym__str_double] = { + .visible = false, + .named = false, + }, + [aux_sym__str_single] = { + .visible = false, + .named = false, + }, + [aux_sym_array_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_local_bind_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_objinside_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_objforloop_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_objforloop_repeat2] = { + .visible = false, + .named = false, + }, + [aux_sym_compspec_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_args_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_params_repeat1] = { + .visible = false, + .named = false, + }, +}; + +enum { + field_alternative = 1, + field_argument = 2, + field_body = 3, + field_condition = 4, + field_consequence = 5, + field_function = 6, + field_identifier = 7, + field_last = 8, + field_left = 9, + field_operator = 10, + field_params = 11, + field_right = 12, + field_value = 13, +}; + +static const char * const ts_field_names[] = { + [0] = NULL, + [field_alternative] = "alternative", + [field_argument] = "argument", + [field_body] = "body", + [field_condition] = "condition", + [field_consequence] = "consequence", + [field_function] = "function", + [field_identifier] = "identifier", + [field_last] = "last", + [field_left] = "left", + [field_operator] = "operator", + [field_params] = "params", + [field_right] = "right", + [field_value] = "value", +}; + +static const TSFieldMapSlice ts_field_map_slices[PRODUCTION_ID_COUNT] = { + [2] = {.index = 0, .length = 2}, + [4] = {.index = 2, .length = 1}, + [6] = {.index = 3, .length = 1}, + [7] = {.index = 4, .length = 3}, + [8] = {.index = 7, .length = 2}, + [9] = {.index = 9, .length = 1}, + [11] = {.index = 10, .length = 2}, + [12] = {.index = 12, .length = 2}, + [13] = {.index = 14, .length = 2}, + [14] = {.index = 16, .length = 1}, + [15] = {.index = 17, .length = 3}, + [16] = {.index = 20, .length = 3}, +}; + +static const TSFieldMapEntry ts_field_map_entries[] = { + [0] = + {field_argument, 1}, + {field_operator, 0}, + [2] = + {field_identifier, 0}, + [3] = + {field_last, 2}, + [4] = + {field_left, 0}, + {field_operator, 1}, + {field_right, 2}, + [7] = + {field_condition, 1}, + {field_consequence, 3}, + [9] = + {field_body, 3}, + [10] = + {field_identifier, 0}, + {field_value, 2}, + [12] = + {field_body, 4}, + {field_params, 2}, + [14] = + {field_body, 4}, + {field_function, 0}, + [16] = + {field_function, 0}, + [17] = + {field_alternative, 5}, + {field_condition, 1}, + {field_consequence, 3}, + [20] = + {field_body, 5}, + {field_function, 0}, + {field_params, 2}, +}; + +static const TSSymbol ts_alias_sequences[PRODUCTION_ID_COUNT][MAX_ALIAS_SEQUENCE_LENGTH] = { + [0] = {0}, + [1] = { + [1] = sym__string_end, + }, + [3] = { + [1] = sym__string_content, + [2] = sym__string_end, + }, + [5] = { + [2] = sym__string_end, + }, + [10] = { + [2] = sym__string_content, + [3] = sym__string_end, + }, +}; + +static const uint16_t ts_non_terminal_alias_map[] = { + aux_sym__str_double, 2, + aux_sym__str_double, + sym__string_content, + aux_sym__str_single, 2, + aux_sym__str_single, + sym__string_content, + 0, +}; + +static const TSStateId ts_primary_state_ids[STATE_COUNT] = { + [0] = 0, + [1] = 1, + [2] = 2, + [3] = 2, + [4] = 4, + [5] = 4, + [6] = 6, + [7] = 7, + [8] = 7, + [9] = 9, + [10] = 10, + [11] = 6, + [12] = 9, + [13] = 13, + [14] = 14, + [15] = 14, + [16] = 16, + [17] = 16, + [18] = 18, + [19] = 18, + [20] = 20, + [21] = 21, + [22] = 20, + [23] = 21, + [24] = 24, + [25] = 25, + [26] = 26, + [27] = 27, + [28] = 28, + [29] = 29, + [30] = 30, + [31] = 31, + [32] = 32, + [33] = 33, + [34] = 34, + [35] = 35, + [36] = 36, + [37] = 37, + [38] = 32, + [39] = 36, + [40] = 40, + [41] = 41, + [42] = 26, + [43] = 43, + [44] = 44, + [45] = 45, + [46] = 27, + [47] = 40, + [48] = 48, + [49] = 49, + [50] = 29, + [51] = 51, + [52] = 52, + [53] = 53, + [54] = 54, + [55] = 55, + [56] = 56, + [57] = 57, + [58] = 33, + [59] = 59, + [60] = 60, + [61] = 35, + [62] = 53, + [63] = 63, + [64] = 64, + [65] = 65, + [66] = 66, + [67] = 24, + [68] = 56, + [69] = 57, + [70] = 59, + [71] = 64, + [72] = 52, + [73] = 25, + [74] = 66, + [75] = 75, + [76] = 76, + [77] = 77, + [78] = 75, + [79] = 54, + [80] = 65, + [81] = 76, + [82] = 77, + [83] = 83, + [84] = 84, + [85] = 85, + [86] = 86, + [87] = 87, + [88] = 88, + [89] = 89, + [90] = 90, + [91] = 91, + [92] = 92, + [93] = 93, + [94] = 94, + [95] = 95, + [96] = 96, + [97] = 97, + [98] = 98, + [99] = 99, + [100] = 100, + [101] = 101, + [102] = 102, + [103] = 103, + [104] = 104, + [105] = 103, + [106] = 106, + [107] = 107, + [108] = 108, + [109] = 109, + [110] = 110, + [111] = 111, + [112] = 112, + [113] = 113, + [114] = 114, + [115] = 115, + [116] = 116, + [117] = 117, + [118] = 118, + [119] = 119, + [120] = 120, + [121] = 121, + [122] = 122, + [123] = 123, + [124] = 124, + [125] = 125, + [126] = 126, + [127] = 127, + [128] = 128, + [129] = 129, + [130] = 130, + [131] = 131, + [132] = 132, + [133] = 133, + [134] = 134, + [135] = 135, + [136] = 136, + [137] = 137, + [138] = 138, + [139] = 139, + [140] = 140, + [141] = 141, + [142] = 142, + [143] = 143, + [144] = 144, + [145] = 145, + [146] = 146, + [147] = 147, + [148] = 148, + [149] = 149, + [150] = 150, + [151] = 151, + [152] = 152, + [153] = 94, + [154] = 154, + [155] = 88, + [156] = 90, + [157] = 91, + [158] = 84, + [159] = 95, + [160] = 92, + [161] = 83, + [162] = 101, + [163] = 96, + [164] = 98, + [165] = 106, + [166] = 166, + [167] = 89, + [168] = 100, + [169] = 169, + [170] = 97, + [171] = 171, + [172] = 172, + [173] = 99, + [174] = 166, + [175] = 86, + [176] = 87, + [177] = 172, + [178] = 93, + [179] = 171, + [180] = 85, + [181] = 181, + [182] = 182, + [183] = 183, + [184] = 184, + [185] = 184, + [186] = 186, + [187] = 187, + [188] = 187, + [189] = 189, + [190] = 182, + [191] = 191, + [192] = 186, + [193] = 191, + [194] = 183, + [195] = 113, + [196] = 141, + [197] = 109, + [198] = 145, + [199] = 116, + [200] = 102, + [201] = 201, + [202] = 104, + [203] = 203, + [204] = 204, + [205] = 205, + [206] = 206, + [207] = 206, + [208] = 208, + [209] = 209, + [210] = 210, + [211] = 128, + [212] = 127, + [213] = 122, + [214] = 139, + [215] = 129, + [216] = 140, + [217] = 112, + [218] = 126, + [219] = 142, + [220] = 143, + [221] = 138, + [222] = 137, + [223] = 124, + [224] = 130, + [225] = 146, + [226] = 107, + [227] = 114, + [228] = 111, + [229] = 120, + [230] = 110, + [231] = 121, + [232] = 123, + [233] = 136, + [234] = 117, + [235] = 133, + [236] = 115, + [237] = 119, + [238] = 108, + [239] = 239, + [240] = 239, + [241] = 241, + [242] = 241, + [243] = 243, + [244] = 243, + [245] = 245, + [246] = 246, + [247] = 247, + [248] = 248, + [249] = 249, + [250] = 250, + [251] = 251, + [252] = 252, + [253] = 253, + [254] = 254, + [255] = 255, + [256] = 256, + [257] = 255, + [258] = 254, + [259] = 259, + [260] = 259, + [261] = 261, + [262] = 261, + [263] = 263, + [264] = 264, + [265] = 265, + [266] = 263, + [267] = 267, + [268] = 268, + [269] = 269, + [270] = 270, + [271] = 271, + [272] = 272, + [273] = 273, + [274] = 274, + [275] = 275, + [276] = 276, + [277] = 277, + [278] = 278, + [279] = 279, + [280] = 275, + [281] = 281, + [282] = 282, + [283] = 283, + [284] = 284, + [285] = 285, + [286] = 286, + [287] = 276, + [288] = 274, + [289] = 289, + [290] = 273, + [291] = 291, + [292] = 292, + [293] = 293, + [294] = 294, + [295] = 281, + [296] = 285, + [297] = 297, + [298] = 271, + [299] = 299, + [300] = 286, + [301] = 301, + [302] = 301, + [303] = 303, + [304] = 304, + [305] = 305, + [306] = 306, + [307] = 307, + [308] = 308, + [309] = 305, + [310] = 310, + [311] = 311, + [312] = 312, + [313] = 303, + [314] = 314, + [315] = 315, + [316] = 316, + [317] = 317, + [318] = 318, + [319] = 319, + [320] = 320, + [321] = 321, + [322] = 322, + [323] = 321, + [324] = 324, + [325] = 325, + [326] = 304, + [327] = 307, + [328] = 328, + [329] = 329, + [330] = 330, + [331] = 331, + [332] = 332, + [333] = 333, + [334] = 334, + [335] = 334, + [336] = 336, + [337] = 337, + [338] = 338, + [339] = 339, + [340] = 340, + [341] = 336, + [342] = 342, + [343] = 343, + [344] = 344, + [345] = 345, + [346] = 346, + [347] = 346, + [348] = 338, + [349] = 349, + [350] = 350, + [351] = 351, + [352] = 352, + [353] = 353, + [354] = 354, + [355] = 355, + [356] = 356, + [357] = 357, + [358] = 352, + [359] = 357, + [360] = 360, + [361] = 361, + [362] = 361, + [363] = 363, + [364] = 364, + [365] = 365, + [366] = 365, + [367] = 354, + [368] = 368, + [369] = 363, + [370] = 370, + [371] = 371, + [372] = 372, + [373] = 373, + [374] = 374, + [375] = 375, + [376] = 376, + [377] = 377, + [378] = 370, + [379] = 379, + [380] = 371, + [381] = 381, + [382] = 376, + [383] = 383, + [384] = 383, + [385] = 372, +}; + +static bool ts_lex(TSLexer *lexer, TSStateId state) { + START_LEXER(); + eof = lexer->eof(lexer); + switch (state) { + case 0: + if (eof) ADVANCE(20); + if (lookahead == '!') ADVANCE(58); + if (lookahead == '"') ADVANCE(73); + if (lookahead == '#') ADVANCE(22); + if (lookahead == '$') ADVANCE(23); + if (lookahead == '%') ADVANCE(39); + if (lookahead == '&') ADVANCE(52); + if (lookahead == '\'') ADVANCE(72); + if (lookahead == '(') ADVANCE(33); + if (lookahead == ')') ADVANCE(34); + if (lookahead == '*') ADVANCE(37); + if (lookahead == '+') ADVANCE(41); + if (lookahead == ',') ADVANCE(27); + if (lookahead == '-') ADVANCE(43); + if (lookahead == '.') ADVANCE(30); + if (lookahead == '/') ADVANCE(38); + if (lookahead == '0') ADVANCE(63); + if (lookahead == ':') ADVANCE(32); + if (lookahead == ';') ADVANCE(36); + if (lookahead == '<') ADVANCE(46); + if (lookahead == '=') ADVANCE(62); + if (lookahead == '>') ADVANCE(48); + if (lookahead == '@') ADVANCE(71); + if (lookahead == '[') ADVANCE(26); + if (lookahead == '\\') ADVANCE(13); + if (lookahead == ']') ADVANCE(28); + if (lookahead == '^') ADVANCE(53); + if (lookahead == '{') ADVANCE(24); + if (lookahead == '|') ADVANCE(54); + if (lookahead == '}') ADVANCE(25); + if (lookahead == '~') ADVANCE(59); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(17) + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(65); + if (('A' <= lookahead && lookahead <= '_') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(35); + END_STATE(); + case 1: + if (lookahead == '\n') SKIP(4) + if (lookahead == '"') ADVANCE(73); + if (lookahead == '#') ADVANCE(78); + if (lookahead == '/') ADVANCE(75); + if (lookahead == '\\') ADVANCE(13); + if (lookahead == '\t' || + lookahead == '\r' || + lookahead == ' ') ADVANCE(74); + if (lookahead != 0) ADVANCE(78); + END_STATE(); + case 2: + if (lookahead == '\n') SKIP(5) + if (lookahead == '#') ADVANCE(83); + if (lookahead == '\'') ADVANCE(72); + if (lookahead == '/') ADVANCE(80); + if (lookahead == '\\') ADVANCE(13); + if (lookahead == '\t' || + lookahead == '\r' || + lookahead == ' ') ADVANCE(79); + if (lookahead != 0) ADVANCE(83); + END_STATE(); + case 3: + if (lookahead == '!') ADVANCE(57); + if (lookahead == '"') ADVANCE(73); + if (lookahead == '#') ADVANCE(22); + if (lookahead == '$') ADVANCE(23); + if (lookahead == '\'') ADVANCE(72); + if (lookahead == '(') ADVANCE(33); + if (lookahead == ')') ADVANCE(34); + if (lookahead == '+') ADVANCE(41); + if (lookahead == '-') ADVANCE(43); + if (lookahead == '.') ADVANCE(14); + if (lookahead == '/') ADVANCE(6); + if (lookahead == '0') ADVANCE(63); + if (lookahead == ':') ADVANCE(31); + if (lookahead == '@') ADVANCE(71); + if (lookahead == '[') ADVANCE(26); + if (lookahead == ']') ADVANCE(28); + if (lookahead == '{') ADVANCE(24); + if (lookahead == '~') ADVANCE(59); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(3) + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(65); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(35); + END_STATE(); + case 4: + if (lookahead == '"') ADVANCE(73); + if (lookahead == '#') ADVANCE(22); + if (lookahead == '/') ADVANCE(6); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(4) + END_STATE(); + case 5: + if (lookahead == '#') ADVANCE(22); + if (lookahead == '\'') ADVANCE(72); + if (lookahead == '/') ADVANCE(6); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(5) + END_STATE(); + case 6: + if (lookahead == '*') ADVANCE(8); + if (lookahead == '/') ADVANCE(22); + END_STATE(); + case 7: + if (lookahead == '*') ADVANCE(7); + if (lookahead == '/') ADVANCE(21); + if (lookahead != 0) ADVANCE(8); + END_STATE(); + case 8: + if (lookahead == '*') ADVANCE(7); + if (lookahead != 0) ADVANCE(8); + END_STATE(); + case 9: + if (lookahead == '=') ADVANCE(51); + END_STATE(); + case 10: + if (lookahead == '+' || + lookahead == '-') ADVANCE(15); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(69); + END_STATE(); + case 11: + if (lookahead == '0' || + lookahead == '1') ADVANCE(67); + END_STATE(); + case 12: + if (('0' <= lookahead && lookahead <= '7')) ADVANCE(68); + END_STATE(); + case 13: + if (lookahead == '"' || + lookahead == '/' || + lookahead == '\\' || + lookahead == 'b' || + lookahead == 'f' || + lookahead == 'n' || + lookahead == 'r' || + lookahead == 't' || + lookahead == 'u') ADVANCE(84); + END_STATE(); + case 14: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(66); + END_STATE(); + case 15: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(69); + END_STATE(); + case 16: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(70); + END_STATE(); + case 17: + if (eof) ADVANCE(20); + if (lookahead == '!') ADVANCE(58); + if (lookahead == '"') ADVANCE(73); + if (lookahead == '#') ADVANCE(22); + if (lookahead == '$') ADVANCE(23); + if (lookahead == '%') ADVANCE(39); + if (lookahead == '&') ADVANCE(52); + if (lookahead == '\'') ADVANCE(72); + if (lookahead == '(') ADVANCE(33); + if (lookahead == ')') ADVANCE(34); + if (lookahead == '*') ADVANCE(37); + if (lookahead == '+') ADVANCE(41); + if (lookahead == ',') ADVANCE(27); + if (lookahead == '-') ADVANCE(43); + if (lookahead == '.') ADVANCE(30); + if (lookahead == '/') ADVANCE(38); + if (lookahead == '0') ADVANCE(63); + if (lookahead == ':') ADVANCE(32); + if (lookahead == ';') ADVANCE(36); + if (lookahead == '<') ADVANCE(46); + if (lookahead == '=') ADVANCE(62); + if (lookahead == '>') ADVANCE(48); + if (lookahead == '@') ADVANCE(71); + if (lookahead == '[') ADVANCE(26); + if (lookahead == ']') ADVANCE(28); + if (lookahead == '^') ADVANCE(53); + if (lookahead == '{') ADVANCE(24); + if (lookahead == '|') ADVANCE(54); + if (lookahead == '}') ADVANCE(25); + if (lookahead == '~') ADVANCE(59); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(17) + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(65); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(35); + END_STATE(); + case 18: + if (eof) ADVANCE(20); + if (lookahead == '!') ADVANCE(9); + if (lookahead == '#') ADVANCE(22); + if (lookahead == '%') ADVANCE(39); + if (lookahead == '&') ADVANCE(52); + if (lookahead == '(') ADVANCE(33); + if (lookahead == ')') ADVANCE(34); + if (lookahead == '*') ADVANCE(37); + if (lookahead == '+') ADVANCE(40); + if (lookahead == ',') ADVANCE(27); + if (lookahead == '-') ADVANCE(42); + if (lookahead == '.') ADVANCE(29); + if (lookahead == '/') ADVANCE(38); + if (lookahead == ':') ADVANCE(32); + if (lookahead == '<') ADVANCE(46); + if (lookahead == '=') ADVANCE(62); + if (lookahead == '>') ADVANCE(48); + if (lookahead == '[') ADVANCE(26); + if (lookahead == '^') ADVANCE(53); + if (lookahead == '{') ADVANCE(24); + if (lookahead == '|') ADVANCE(54); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(18) + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(35); + END_STATE(); + case 19: + if (eof) ADVANCE(20); + if (lookahead == '!') ADVANCE(9); + if (lookahead == '#') ADVANCE(22); + if (lookahead == '%') ADVANCE(39); + if (lookahead == '&') ADVANCE(52); + if (lookahead == '(') ADVANCE(33); + if (lookahead == ')') ADVANCE(34); + if (lookahead == '*') ADVANCE(37); + if (lookahead == '+') ADVANCE(40); + if (lookahead == ',') ADVANCE(27); + if (lookahead == '-') ADVANCE(42); + if (lookahead == '.') ADVANCE(29); + if (lookahead == '/') ADVANCE(38); + if (lookahead == ':') ADVANCE(31); + if (lookahead == ';') ADVANCE(36); + if (lookahead == '<') ADVANCE(46); + if (lookahead == '=') ADVANCE(62); + if (lookahead == '>') ADVANCE(48); + if (lookahead == '[') ADVANCE(26); + if (lookahead == ']') ADVANCE(28); + if (lookahead == '^') ADVANCE(53); + if (lookahead == '{') ADVANCE(24); + if (lookahead == '|') ADVANCE(54); + if (lookahead == '}') ADVANCE(25); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(19) + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(35); + END_STATE(); + case 20: + ACCEPT_TOKEN(ts_builtin_sym_end); + END_STATE(); + case 21: + ACCEPT_TOKEN(sym_comment); + END_STATE(); + case 22: + ACCEPT_TOKEN(sym_comment); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(22); + END_STATE(); + case 23: + ACCEPT_TOKEN(sym_dollar); + END_STATE(); + case 24: + ACCEPT_TOKEN(anon_sym_LBRACE); + END_STATE(); + case 25: + ACCEPT_TOKEN(anon_sym_RBRACE); + END_STATE(); + case 26: + ACCEPT_TOKEN(anon_sym_LBRACK); + END_STATE(); + case 27: + ACCEPT_TOKEN(anon_sym_COMMA); + END_STATE(); + case 28: + ACCEPT_TOKEN(anon_sym_RBRACK); + END_STATE(); + case 29: + ACCEPT_TOKEN(anon_sym_DOT); + END_STATE(); + case 30: + ACCEPT_TOKEN(anon_sym_DOT); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(66); + END_STATE(); + case 31: + ACCEPT_TOKEN(anon_sym_COLON); + END_STATE(); + case 32: + ACCEPT_TOKEN(anon_sym_COLON); + if (lookahead == ':') ADVANCE(60); + END_STATE(); + case 33: + ACCEPT_TOKEN(anon_sym_LPAREN); + END_STATE(); + case 34: + ACCEPT_TOKEN(anon_sym_RPAREN); + END_STATE(); + case 35: + ACCEPT_TOKEN(sym__ident); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(35); + END_STATE(); + case 36: + ACCEPT_TOKEN(anon_sym_SEMI); + END_STATE(); + case 37: + ACCEPT_TOKEN(anon_sym_STAR); + END_STATE(); + case 38: + ACCEPT_TOKEN(anon_sym_SLASH); + if (lookahead == '*') ADVANCE(8); + if (lookahead == '/') ADVANCE(22); + END_STATE(); + case 39: + ACCEPT_TOKEN(anon_sym_PERCENT); + END_STATE(); + case 40: + ACCEPT_TOKEN(anon_sym_PLUS); + END_STATE(); + case 41: + ACCEPT_TOKEN(anon_sym_PLUS); + if (lookahead == '0') ADVANCE(64); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(65); + END_STATE(); + case 42: + ACCEPT_TOKEN(anon_sym_DASH); + END_STATE(); + case 43: + ACCEPT_TOKEN(anon_sym_DASH); + if (lookahead == '0') ADVANCE(64); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(65); + END_STATE(); + case 44: + ACCEPT_TOKEN(anon_sym_LT_LT); + END_STATE(); + case 45: + ACCEPT_TOKEN(anon_sym_GT_GT); + END_STATE(); + case 46: + ACCEPT_TOKEN(anon_sym_LT); + if (lookahead == '<') ADVANCE(44); + if (lookahead == '=') ADVANCE(47); + END_STATE(); + case 47: + ACCEPT_TOKEN(anon_sym_LT_EQ); + END_STATE(); + case 48: + ACCEPT_TOKEN(anon_sym_GT); + if (lookahead == '=') ADVANCE(49); + if (lookahead == '>') ADVANCE(45); + END_STATE(); + case 49: + ACCEPT_TOKEN(anon_sym_GT_EQ); + END_STATE(); + case 50: + ACCEPT_TOKEN(anon_sym_EQ_EQ); + END_STATE(); + case 51: + ACCEPT_TOKEN(anon_sym_BANG_EQ); + END_STATE(); + case 52: + ACCEPT_TOKEN(sym_bitand); + if (lookahead == '&') ADVANCE(55); + END_STATE(); + case 53: + ACCEPT_TOKEN(sym_bitxor); + END_STATE(); + case 54: + ACCEPT_TOKEN(sym_bitor); + if (lookahead == '|') ADVANCE(56); + END_STATE(); + case 55: + ACCEPT_TOKEN(sym_and); + END_STATE(); + case 56: + ACCEPT_TOKEN(sym_or); + END_STATE(); + case 57: + ACCEPT_TOKEN(anon_sym_BANG); + END_STATE(); + case 58: + ACCEPT_TOKEN(anon_sym_BANG); + if (lookahead == '=') ADVANCE(51); + END_STATE(); + case 59: + ACCEPT_TOKEN(anon_sym_TILDE); + END_STATE(); + case 60: + ACCEPT_TOKEN(anon_sym_COLON_COLON); + if (lookahead == ':') ADVANCE(61); + END_STATE(); + case 61: + ACCEPT_TOKEN(anon_sym_COLON_COLON_COLON); + END_STATE(); + case 62: + ACCEPT_TOKEN(anon_sym_EQ); + if (lookahead == '=') ADVANCE(50); + END_STATE(); + case 63: + ACCEPT_TOKEN(sym__number); + if (lookahead == '.') ADVANCE(66); + if (lookahead == 'B' || + lookahead == 'b') ADVANCE(11); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(10); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(12); + if (lookahead == 'X' || + lookahead == 'x') ADVANCE(16); + END_STATE(); + case 64: + ACCEPT_TOKEN(sym__number); + if (lookahead == '.') ADVANCE(66); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(10); + END_STATE(); + case 65: + ACCEPT_TOKEN(sym__number); + if (lookahead == '.') ADVANCE(66); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(10); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(65); + END_STATE(); + case 66: + ACCEPT_TOKEN(sym__number); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(10); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(66); + END_STATE(); + case 67: + ACCEPT_TOKEN(sym__number); + if (lookahead == '0' || + lookahead == '1') ADVANCE(67); + END_STATE(); + case 68: + ACCEPT_TOKEN(sym__number); + if (('0' <= lookahead && lookahead <= '7')) ADVANCE(68); + END_STATE(); + case 69: + ACCEPT_TOKEN(sym__number); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(69); + END_STATE(); + case 70: + ACCEPT_TOKEN(sym__number); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(70); + END_STATE(); + case 71: + ACCEPT_TOKEN(anon_sym_AT); + END_STATE(); + case 72: + ACCEPT_TOKEN(sym__single); + END_STATE(); + case 73: + ACCEPT_TOKEN(sym__double); + END_STATE(); + case 74: + ACCEPT_TOKEN(aux_sym__str_double_token1); + if (lookahead == '#') ADVANCE(78); + if (lookahead == '/') ADVANCE(75); + if (lookahead == '\t' || + lookahead == '\r' || + lookahead == ' ') ADVANCE(74); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '"' && + lookahead != '\\') ADVANCE(78); + END_STATE(); + case 75: + ACCEPT_TOKEN(aux_sym__str_double_token1); + if (lookahead == '*') ADVANCE(77); + if (lookahead == '/') ADVANCE(78); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '"' && + lookahead != '\\') ADVANCE(78); + END_STATE(); + case 76: + ACCEPT_TOKEN(aux_sym__str_double_token1); + if (lookahead == '*') ADVANCE(76); + if (lookahead == '/') ADVANCE(78); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '"' && + lookahead != '\\') ADVANCE(77); + END_STATE(); + case 77: + ACCEPT_TOKEN(aux_sym__str_double_token1); + if (lookahead == '*') ADVANCE(76); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '"' && + lookahead != '\\') ADVANCE(77); + END_STATE(); + case 78: + ACCEPT_TOKEN(aux_sym__str_double_token1); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '"' && + lookahead != '\\') ADVANCE(78); + END_STATE(); + case 79: + ACCEPT_TOKEN(aux_sym__str_single_token1); + if (lookahead == '#') ADVANCE(83); + if (lookahead == '/') ADVANCE(80); + if (lookahead == '\t' || + lookahead == '\r' || + lookahead == ' ') ADVANCE(79); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '\'' && + lookahead != '\\') ADVANCE(83); + END_STATE(); + case 80: + ACCEPT_TOKEN(aux_sym__str_single_token1); + if (lookahead == '*') ADVANCE(82); + if (lookahead == '/') ADVANCE(83); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '\'' && + lookahead != '\\') ADVANCE(83); + END_STATE(); + case 81: + ACCEPT_TOKEN(aux_sym__str_single_token1); + if (lookahead == '*') ADVANCE(81); + if (lookahead == '/') ADVANCE(83); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '\'' && + lookahead != '\\') ADVANCE(82); + END_STATE(); + case 82: + ACCEPT_TOKEN(aux_sym__str_single_token1); + if (lookahead == '*') ADVANCE(81); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '\'' && + lookahead != '\\') ADVANCE(82); + END_STATE(); + case 83: + ACCEPT_TOKEN(aux_sym__str_single_token1); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '\'' && + lookahead != '\\') ADVANCE(83); + END_STATE(); + case 84: + ACCEPT_TOKEN(sym_escape_sequence); + END_STATE(); + default: + return false; + } +} + +static bool ts_lex_keywords(TSLexer *lexer, TSStateId state) { + START_LEXER(); + eof = lexer->eof(lexer); + switch (state) { + case 0: + if (lookahead == 'a') ADVANCE(1); + if (lookahead == 'e') ADVANCE(2); + if (lookahead == 'f') ADVANCE(3); + if (lookahead == 'i') ADVANCE(4); + if (lookahead == 'l') ADVANCE(5); + if (lookahead == 'n') ADVANCE(6); + if (lookahead == 's') ADVANCE(7); + if (lookahead == 't') ADVANCE(8); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(0) + END_STATE(); + case 1: + if (lookahead == 's') ADVANCE(9); + END_STATE(); + case 2: + if (lookahead == 'l') ADVANCE(10); + if (lookahead == 'r') ADVANCE(11); + END_STATE(); + case 3: + if (lookahead == 'a') ADVANCE(12); + if (lookahead == 'o') ADVANCE(13); + if (lookahead == 'u') ADVANCE(14); + END_STATE(); + case 4: + if (lookahead == 'f') ADVANCE(15); + if (lookahead == 'm') ADVANCE(16); + if (lookahead == 'n') ADVANCE(17); + END_STATE(); + case 5: + if (lookahead == 'o') ADVANCE(18); + END_STATE(); + case 6: + if (lookahead == 'u') ADVANCE(19); + END_STATE(); + case 7: + if (lookahead == 'e') ADVANCE(20); + if (lookahead == 'u') ADVANCE(21); + END_STATE(); + case 8: + if (lookahead == 'a') ADVANCE(22); + if (lookahead == 'h') ADVANCE(23); + if (lookahead == 'r') ADVANCE(24); + END_STATE(); + case 9: + if (lookahead == 's') ADVANCE(25); + END_STATE(); + case 10: + if (lookahead == 's') ADVANCE(26); + END_STATE(); + case 11: + if (lookahead == 'r') ADVANCE(27); + END_STATE(); + case 12: + if (lookahead == 'l') ADVANCE(28); + END_STATE(); + case 13: + if (lookahead == 'r') ADVANCE(29); + END_STATE(); + case 14: + if (lookahead == 'n') ADVANCE(30); + END_STATE(); + case 15: + ACCEPT_TOKEN(anon_sym_if); + END_STATE(); + case 16: + if (lookahead == 'p') ADVANCE(31); + END_STATE(); + case 17: + ACCEPT_TOKEN(anon_sym_in); + END_STATE(); + case 18: + if (lookahead == 'c') ADVANCE(32); + END_STATE(); + case 19: + if (lookahead == 'l') ADVANCE(33); + END_STATE(); + case 20: + if (lookahead == 'l') ADVANCE(34); + END_STATE(); + case 21: + if (lookahead == 'p') ADVANCE(35); + END_STATE(); + case 22: + if (lookahead == 'i') ADVANCE(36); + END_STATE(); + case 23: + if (lookahead == 'e') ADVANCE(37); + END_STATE(); + case 24: + if (lookahead == 'u') ADVANCE(38); + END_STATE(); + case 25: + if (lookahead == 'e') ADVANCE(39); + END_STATE(); + case 26: + if (lookahead == 'e') ADVANCE(40); + END_STATE(); + case 27: + if (lookahead == 'o') ADVANCE(41); + END_STATE(); + case 28: + if (lookahead == 's') ADVANCE(42); + END_STATE(); + case 29: + ACCEPT_TOKEN(anon_sym_for); + END_STATE(); + case 30: + if (lookahead == 'c') ADVANCE(43); + END_STATE(); + case 31: + if (lookahead == 'o') ADVANCE(44); + END_STATE(); + case 32: + if (lookahead == 'a') ADVANCE(45); + END_STATE(); + case 33: + if (lookahead == 'l') ADVANCE(46); + END_STATE(); + case 34: + if (lookahead == 'f') ADVANCE(47); + END_STATE(); + case 35: + if (lookahead == 'e') ADVANCE(48); + END_STATE(); + case 36: + if (lookahead == 'l') ADVANCE(49); + END_STATE(); + case 37: + if (lookahead == 'n') ADVANCE(50); + END_STATE(); + case 38: + if (lookahead == 'e') ADVANCE(51); + END_STATE(); + case 39: + if (lookahead == 'r') ADVANCE(52); + END_STATE(); + case 40: + ACCEPT_TOKEN(anon_sym_else); + END_STATE(); + case 41: + if (lookahead == 'r') ADVANCE(53); + END_STATE(); + case 42: + if (lookahead == 'e') ADVANCE(54); + END_STATE(); + case 43: + if (lookahead == 't') ADVANCE(55); + END_STATE(); + case 44: + if (lookahead == 'r') ADVANCE(56); + END_STATE(); + case 45: + if (lookahead == 'l') ADVANCE(57); + END_STATE(); + case 46: + ACCEPT_TOKEN(sym_null); + END_STATE(); + case 47: + ACCEPT_TOKEN(sym_self); + END_STATE(); + case 48: + if (lookahead == 'r') ADVANCE(58); + END_STATE(); + case 49: + if (lookahead == 's') ADVANCE(59); + END_STATE(); + case 50: + ACCEPT_TOKEN(anon_sym_then); + END_STATE(); + case 51: + ACCEPT_TOKEN(sym_true); + END_STATE(); + case 52: + if (lookahead == 't') ADVANCE(60); + END_STATE(); + case 53: + ACCEPT_TOKEN(anon_sym_error); + END_STATE(); + case 54: + ACCEPT_TOKEN(sym_false); + END_STATE(); + case 55: + if (lookahead == 'i') ADVANCE(61); + END_STATE(); + case 56: + if (lookahead == 't') ADVANCE(62); + END_STATE(); + case 57: + ACCEPT_TOKEN(sym_local); + END_STATE(); + case 58: + ACCEPT_TOKEN(sym_super); + END_STATE(); + case 59: + if (lookahead == 't') ADVANCE(63); + END_STATE(); + case 60: + ACCEPT_TOKEN(anon_sym_assert); + END_STATE(); + case 61: + if (lookahead == 'o') ADVANCE(64); + END_STATE(); + case 62: + ACCEPT_TOKEN(anon_sym_import); + if (lookahead == 's') ADVANCE(65); + END_STATE(); + case 63: + if (lookahead == 'r') ADVANCE(66); + END_STATE(); + case 64: + if (lookahead == 'n') ADVANCE(67); + END_STATE(); + case 65: + if (lookahead == 't') ADVANCE(68); + END_STATE(); + case 66: + if (lookahead == 'i') ADVANCE(69); + END_STATE(); + case 67: + ACCEPT_TOKEN(anon_sym_function); + END_STATE(); + case 68: + if (lookahead == 'r') ADVANCE(70); + END_STATE(); + case 69: + if (lookahead == 'c') ADVANCE(71); + END_STATE(); + case 70: + ACCEPT_TOKEN(anon_sym_importstr); + END_STATE(); + case 71: + if (lookahead == 't') ADVANCE(72); + END_STATE(); + case 72: + ACCEPT_TOKEN(sym_tailstrict); + END_STATE(); + default: + return false; + } +} + +static const TSLexMode ts_lex_modes[STATE_COUNT] = { + [0] = {.lex_state = 0, .external_lex_state = 1}, + [1] = {.lex_state = 3, .external_lex_state = 2}, + [2] = {.lex_state = 3, .external_lex_state = 2}, + [3] = {.lex_state = 3, .external_lex_state = 2}, + [4] = {.lex_state = 3, .external_lex_state = 2}, + [5] = {.lex_state = 3, .external_lex_state = 2}, + [6] = {.lex_state = 3, .external_lex_state = 2}, + [7] = {.lex_state = 3, .external_lex_state = 2}, + [8] = {.lex_state = 3, .external_lex_state = 2}, + [9] = {.lex_state = 3, .external_lex_state = 2}, + [10] = {.lex_state = 3, .external_lex_state = 2}, + [11] = {.lex_state = 3, .external_lex_state = 2}, + [12] = {.lex_state = 3, .external_lex_state = 2}, + [13] = {.lex_state = 3, .external_lex_state = 2}, + [14] = {.lex_state = 3, .external_lex_state = 2}, + [15] = {.lex_state = 3, .external_lex_state = 2}, + [16] = {.lex_state = 3, .external_lex_state = 2}, + [17] = {.lex_state = 3, .external_lex_state = 2}, + [18] = {.lex_state = 3, .external_lex_state = 2}, + [19] = {.lex_state = 3, .external_lex_state = 2}, + [20] = {.lex_state = 3, .external_lex_state = 2}, + [21] = {.lex_state = 3, .external_lex_state = 2}, + [22] = {.lex_state = 3, .external_lex_state = 2}, + [23] = {.lex_state = 3, .external_lex_state = 2}, + [24] = {.lex_state = 3, .external_lex_state = 2}, + [25] = {.lex_state = 3, .external_lex_state = 2}, + [26] = {.lex_state = 3, .external_lex_state = 2}, + [27] = {.lex_state = 3, .external_lex_state = 2}, + [28] = {.lex_state = 3, .external_lex_state = 2}, + [29] = {.lex_state = 3, .external_lex_state = 2}, + [30] = {.lex_state = 3, .external_lex_state = 2}, + [31] = {.lex_state = 3, .external_lex_state = 2}, + [32] = {.lex_state = 3, .external_lex_state = 2}, + [33] = {.lex_state = 3, .external_lex_state = 2}, + [34] = {.lex_state = 3, .external_lex_state = 2}, + [35] = {.lex_state = 3, .external_lex_state = 2}, + [36] = {.lex_state = 3, .external_lex_state = 2}, + [37] = {.lex_state = 3, .external_lex_state = 2}, + [38] = {.lex_state = 3, .external_lex_state = 2}, + [39] = {.lex_state = 3, .external_lex_state = 2}, + [40] = {.lex_state = 3, .external_lex_state = 2}, + [41] = {.lex_state = 3, .external_lex_state = 2}, + [42] = {.lex_state = 3, .external_lex_state = 2}, + [43] = {.lex_state = 3, .external_lex_state = 2}, + [44] = {.lex_state = 3, .external_lex_state = 2}, + [45] = {.lex_state = 3, .external_lex_state = 2}, + [46] = {.lex_state = 3, .external_lex_state = 2}, + [47] = {.lex_state = 3, .external_lex_state = 2}, + [48] = {.lex_state = 3, .external_lex_state = 2}, + [49] = {.lex_state = 3, .external_lex_state = 2}, + [50] = {.lex_state = 3, .external_lex_state = 2}, + [51] = {.lex_state = 3, .external_lex_state = 2}, + [52] = {.lex_state = 3, .external_lex_state = 2}, + [53] = {.lex_state = 3, .external_lex_state = 2}, + [54] = {.lex_state = 3, .external_lex_state = 2}, + [55] = {.lex_state = 3, .external_lex_state = 2}, + [56] = {.lex_state = 3, .external_lex_state = 2}, + [57] = {.lex_state = 3, .external_lex_state = 2}, + [58] = {.lex_state = 3, .external_lex_state = 2}, + [59] = {.lex_state = 3, .external_lex_state = 2}, + [60] = {.lex_state = 3, .external_lex_state = 2}, + [61] = {.lex_state = 3, .external_lex_state = 2}, + [62] = {.lex_state = 3, .external_lex_state = 2}, + [63] = {.lex_state = 3, .external_lex_state = 2}, + [64] = {.lex_state = 3, .external_lex_state = 2}, + [65] = {.lex_state = 3, .external_lex_state = 2}, + [66] = {.lex_state = 3, .external_lex_state = 2}, + [67] = {.lex_state = 3, .external_lex_state = 2}, + [68] = {.lex_state = 3, .external_lex_state = 2}, + [69] = {.lex_state = 3, .external_lex_state = 2}, + [70] = {.lex_state = 3, .external_lex_state = 2}, + [71] = {.lex_state = 3, .external_lex_state = 2}, + [72] = {.lex_state = 3, .external_lex_state = 2}, + [73] = {.lex_state = 3, .external_lex_state = 2}, + [74] = {.lex_state = 3, .external_lex_state = 2}, + [75] = {.lex_state = 3, .external_lex_state = 2}, + [76] = {.lex_state = 3, .external_lex_state = 2}, + [77] = {.lex_state = 3, .external_lex_state = 2}, + [78] = {.lex_state = 3, .external_lex_state = 2}, + [79] = {.lex_state = 3, .external_lex_state = 2}, + [80] = {.lex_state = 3, .external_lex_state = 2}, + [81] = {.lex_state = 3, .external_lex_state = 2}, + [82] = {.lex_state = 3, .external_lex_state = 2}, + [83] = {.lex_state = 19}, + [84] = {.lex_state = 19}, + [85] = {.lex_state = 19}, + [86] = {.lex_state = 19}, + [87] = {.lex_state = 19}, + [88] = {.lex_state = 19}, + [89] = {.lex_state = 19}, + [90] = {.lex_state = 19}, + [91] = {.lex_state = 19}, + [92] = {.lex_state = 19}, + [93] = {.lex_state = 19}, + [94] = {.lex_state = 19}, + [95] = {.lex_state = 19}, + [96] = {.lex_state = 19}, + [97] = {.lex_state = 19}, + [98] = {.lex_state = 19}, + [99] = {.lex_state = 19}, + [100] = {.lex_state = 19}, + [101] = {.lex_state = 19}, + [102] = {.lex_state = 19}, + [103] = {.lex_state = 19}, + [104] = {.lex_state = 19}, + [105] = {.lex_state = 19}, + [106] = {.lex_state = 19}, + [107] = {.lex_state = 19}, + [108] = {.lex_state = 19}, + [109] = {.lex_state = 19}, + [110] = {.lex_state = 19}, + [111] = {.lex_state = 19}, + [112] = {.lex_state = 19}, + [113] = {.lex_state = 19}, + [114] = {.lex_state = 19}, + [115] = {.lex_state = 19}, + [116] = {.lex_state = 19}, + [117] = {.lex_state = 19}, + [118] = {.lex_state = 19}, + [119] = {.lex_state = 19}, + [120] = {.lex_state = 19}, + [121] = {.lex_state = 19}, + [122] = {.lex_state = 19}, + [123] = {.lex_state = 19}, + [124] = {.lex_state = 19}, + [125] = {.lex_state = 19}, + [126] = {.lex_state = 19}, + [127] = {.lex_state = 19}, + [128] = {.lex_state = 19}, + [129] = {.lex_state = 19}, + [130] = {.lex_state = 19}, + [131] = {.lex_state = 19}, + [132] = {.lex_state = 19}, + [133] = {.lex_state = 19}, + [134] = {.lex_state = 19}, + [135] = {.lex_state = 19}, + [136] = {.lex_state = 19}, + [137] = {.lex_state = 19}, + [138] = {.lex_state = 19}, + [139] = {.lex_state = 19}, + [140] = {.lex_state = 19}, + [141] = {.lex_state = 19}, + [142] = {.lex_state = 19}, + [143] = {.lex_state = 19}, + [144] = {.lex_state = 19}, + [145] = {.lex_state = 19}, + [146] = {.lex_state = 19}, + [147] = {.lex_state = 19}, + [148] = {.lex_state = 19}, + [149] = {.lex_state = 19}, + [150] = {.lex_state = 19}, + [151] = {.lex_state = 19}, + [152] = {.lex_state = 19}, + [153] = {.lex_state = 19}, + [154] = {.lex_state = 19}, + [155] = {.lex_state = 19}, + [156] = {.lex_state = 19}, + [157] = {.lex_state = 19}, + [158] = {.lex_state = 19}, + [159] = {.lex_state = 19}, + [160] = {.lex_state = 19}, + [161] = {.lex_state = 19}, + [162] = {.lex_state = 19}, + [163] = {.lex_state = 19}, + [164] = {.lex_state = 19}, + [165] = {.lex_state = 18}, + [166] = {.lex_state = 19}, + [167] = {.lex_state = 19}, + [168] = {.lex_state = 19}, + [169] = {.lex_state = 19}, + [170] = {.lex_state = 19}, + [171] = {.lex_state = 19}, + [172] = {.lex_state = 19}, + [173] = {.lex_state = 19}, + [174] = {.lex_state = 19}, + [175] = {.lex_state = 19}, + [176] = {.lex_state = 19}, + [177] = {.lex_state = 19}, + [178] = {.lex_state = 19}, + [179] = {.lex_state = 19}, + [180] = {.lex_state = 19}, + [181] = {.lex_state = 19}, + [182] = {.lex_state = 19}, + [183] = {.lex_state = 19}, + [184] = {.lex_state = 19}, + [185] = {.lex_state = 19}, + [186] = {.lex_state = 19}, + [187] = {.lex_state = 19}, + [188] = {.lex_state = 19}, + [189] = {.lex_state = 19}, + [190] = {.lex_state = 19}, + [191] = {.lex_state = 19}, + [192] = {.lex_state = 19}, + [193] = {.lex_state = 19}, + [194] = {.lex_state = 19}, + [195] = {.lex_state = 18}, + [196] = {.lex_state = 18}, + [197] = {.lex_state = 18}, + [198] = {.lex_state = 18}, + [199] = {.lex_state = 18}, + [200] = {.lex_state = 19}, + [201] = {.lex_state = 3, .external_lex_state = 2}, + [202] = {.lex_state = 19}, + [203] = {.lex_state = 3, .external_lex_state = 2}, + [204] = {.lex_state = 19}, + [205] = {.lex_state = 3, .external_lex_state = 2}, + [206] = {.lex_state = 3, .external_lex_state = 2}, + [207] = {.lex_state = 3, .external_lex_state = 2}, + [208] = {.lex_state = 3, .external_lex_state = 2}, + [209] = {.lex_state = 3, .external_lex_state = 2}, + [210] = {.lex_state = 3, .external_lex_state = 2}, + [211] = {.lex_state = 19}, + [212] = {.lex_state = 19}, + [213] = {.lex_state = 19}, + [214] = {.lex_state = 19}, + [215] = {.lex_state = 19}, + [216] = {.lex_state = 19}, + [217] = {.lex_state = 19}, + [218] = {.lex_state = 19}, + [219] = {.lex_state = 19}, + [220] = {.lex_state = 19}, + [221] = {.lex_state = 19}, + [222] = {.lex_state = 19}, + [223] = {.lex_state = 19}, + [224] = {.lex_state = 19}, + [225] = {.lex_state = 19}, + [226] = {.lex_state = 19}, + [227] = {.lex_state = 19}, + [228] = {.lex_state = 19}, + [229] = {.lex_state = 19}, + [230] = {.lex_state = 19}, + [231] = {.lex_state = 19}, + [232] = {.lex_state = 19}, + [233] = {.lex_state = 19}, + [234] = {.lex_state = 19}, + [235] = {.lex_state = 19}, + [236] = {.lex_state = 19}, + [237] = {.lex_state = 19}, + [238] = {.lex_state = 19}, + [239] = {.lex_state = 0, .external_lex_state = 2}, + [240] = {.lex_state = 0, .external_lex_state = 2}, + [241] = {.lex_state = 0, .external_lex_state = 2}, + [242] = {.lex_state = 0, .external_lex_state = 2}, + [243] = {.lex_state = 0, .external_lex_state = 2}, + [244] = {.lex_state = 0, .external_lex_state = 2}, + [245] = {.lex_state = 0, .external_lex_state = 2}, + [246] = {.lex_state = 0, .external_lex_state = 2}, + [247] = {.lex_state = 0, .external_lex_state = 2}, + [248] = {.lex_state = 0}, + [249] = {.lex_state = 0}, + [250] = {.lex_state = 0}, + [251] = {.lex_state = 0}, + [252] = {.lex_state = 0}, + [253] = {.lex_state = 0, .external_lex_state = 2}, + [254] = {.lex_state = 0}, + [255] = {.lex_state = 0}, + [256] = {.lex_state = 0}, + [257] = {.lex_state = 0}, + [258] = {.lex_state = 0}, + [259] = {.lex_state = 0, .external_lex_state = 2}, + [260] = {.lex_state = 0, .external_lex_state = 2}, + [261] = {.lex_state = 0, .external_lex_state = 2}, + [262] = {.lex_state = 0, .external_lex_state = 2}, + [263] = {.lex_state = 0}, + [264] = {.lex_state = 0}, + [265] = {.lex_state = 0}, + [266] = {.lex_state = 0}, + [267] = {.lex_state = 18}, + [268] = {.lex_state = 18}, + [269] = {.lex_state = 18}, + [270] = {.lex_state = 0}, + [271] = {.lex_state = 1}, + [272] = {.lex_state = 0}, + [273] = {.lex_state = 1}, + [274] = {.lex_state = 2}, + [275] = {.lex_state = 1}, + [276] = {.lex_state = 2}, + [277] = {.lex_state = 0}, + [278] = {.lex_state = 1}, + [279] = {.lex_state = 2}, + [280] = {.lex_state = 1}, + [281] = {.lex_state = 2}, + [282] = {.lex_state = 0}, + [283] = {.lex_state = 0}, + [284] = {.lex_state = 0}, + [285] = {.lex_state = 1}, + [286] = {.lex_state = 2}, + [287] = {.lex_state = 2}, + [288] = {.lex_state = 2}, + [289] = {.lex_state = 0}, + [290] = {.lex_state = 1}, + [291] = {.lex_state = 0}, + [292] = {.lex_state = 0}, + [293] = {.lex_state = 0}, + [294] = {.lex_state = 0}, + [295] = {.lex_state = 2}, + [296] = {.lex_state = 1}, + [297] = {.lex_state = 0}, + [298] = {.lex_state = 1}, + [299] = {.lex_state = 0}, + [300] = {.lex_state = 2}, + [301] = {.lex_state = 0}, + [302] = {.lex_state = 0}, + [303] = {.lex_state = 0, .external_lex_state = 2}, + [304] = {.lex_state = 0}, + [305] = {.lex_state = 0}, + [306] = {.lex_state = 0}, + [307] = {.lex_state = 0}, + [308] = {.lex_state = 0}, + [309] = {.lex_state = 0}, + [310] = {.lex_state = 0}, + [311] = {.lex_state = 0}, + [312] = {.lex_state = 0}, + [313] = {.lex_state = 0, .external_lex_state = 2}, + [314] = {.lex_state = 1}, + [315] = {.lex_state = 2}, + [316] = {.lex_state = 0}, + [317] = {.lex_state = 0}, + [318] = {.lex_state = 0}, + [319] = {.lex_state = 0}, + [320] = {.lex_state = 0}, + [321] = {.lex_state = 0}, + [322] = {.lex_state = 0}, + [323] = {.lex_state = 0}, + [324] = {.lex_state = 0}, + [325] = {.lex_state = 0}, + [326] = {.lex_state = 0}, + [327] = {.lex_state = 0}, + [328] = {.lex_state = 0}, + [329] = {.lex_state = 0}, + [330] = {.lex_state = 0}, + [331] = {.lex_state = 0}, + [332] = {.lex_state = 0}, + [333] = {.lex_state = 0}, + [334] = {.lex_state = 0}, + [335] = {.lex_state = 0}, + [336] = {.lex_state = 0}, + [337] = {.lex_state = 0}, + [338] = {.lex_state = 19}, + [339] = {.lex_state = 0}, + [340] = {.lex_state = 0}, + [341] = {.lex_state = 0}, + [342] = {.lex_state = 0}, + [343] = {.lex_state = 0}, + [344] = {.lex_state = 0}, + [345] = {.lex_state = 0}, + [346] = {.lex_state = 0}, + [347] = {.lex_state = 0}, + [348] = {.lex_state = 19}, + [349] = {.lex_state = 0}, + [350] = {.lex_state = 0}, + [351] = {.lex_state = 0}, + [352] = {.lex_state = 0, .external_lex_state = 3}, + [353] = {.lex_state = 0}, + [354] = {.lex_state = 0}, + [355] = {.lex_state = 0}, + [356] = {.lex_state = 0}, + [357] = {.lex_state = 0}, + [358] = {.lex_state = 0, .external_lex_state = 3}, + [359] = {.lex_state = 0}, + [360] = {.lex_state = 0}, + [361] = {.lex_state = 0, .external_lex_state = 3}, + [362] = {.lex_state = 0, .external_lex_state = 3}, + [363] = {.lex_state = 0}, + [364] = {.lex_state = 0}, + [365] = {.lex_state = 0}, + [366] = {.lex_state = 0}, + [367] = {.lex_state = 0}, + [368] = {.lex_state = 0}, + [369] = {.lex_state = 0}, + [370] = {.lex_state = 0, .external_lex_state = 4}, + [371] = {.lex_state = 0}, + [372] = {.lex_state = 0, .external_lex_state = 4}, + [373] = {.lex_state = 0}, + [374] = {.lex_state = 0}, + [375] = {.lex_state = 0}, + [376] = {.lex_state = 0}, + [377] = {.lex_state = 0}, + [378] = {.lex_state = 0, .external_lex_state = 4}, + [379] = {.lex_state = 0}, + [380] = {.lex_state = 0}, + [381] = {.lex_state = 0}, + [382] = {.lex_state = 0}, + [383] = {.lex_state = 0}, + [384] = {.lex_state = 0}, + [385] = {.lex_state = 0, .external_lex_state = 4}, +}; + +enum { + ts_external_token__string_start = 0, + ts_external_token__string_content = 1, + ts_external_token__string_end = 2, +}; + +static const TSSymbol ts_external_scanner_symbol_map[EXTERNAL_TOKEN_COUNT] = { + [ts_external_token__string_start] = sym__string_start, + [ts_external_token__string_content] = sym__string_content, + [ts_external_token__string_end] = sym__string_end, +}; + +static const bool ts_external_scanner_states[5][EXTERNAL_TOKEN_COUNT] = { + [1] = { + [ts_external_token__string_start] = true, + [ts_external_token__string_content] = true, + [ts_external_token__string_end] = true, + }, + [2] = { + [ts_external_token__string_start] = true, + }, + [3] = { + [ts_external_token__string_end] = true, + }, + [4] = { + [ts_external_token__string_content] = true, + }, +}; + +static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { + [0] = { + [ts_builtin_sym_end] = ACTIONS(1), + [sym__ident] = ACTIONS(1), + [sym_comment] = ACTIONS(3), + [sym_null] = ACTIONS(1), + [sym_true] = ACTIONS(1), + [sym_false] = ACTIONS(1), + [sym_self] = ACTIONS(1), + [sym_dollar] = ACTIONS(1), + [sym_super] = ACTIONS(1), + [sym_local] = ACTIONS(1), + [sym_tailstrict] = ACTIONS(1), + [anon_sym_LBRACE] = ACTIONS(1), + [anon_sym_RBRACE] = ACTIONS(1), + [anon_sym_LBRACK] = ACTIONS(1), + [anon_sym_COMMA] = ACTIONS(1), + [anon_sym_RBRACK] = ACTIONS(1), + [anon_sym_DOT] = ACTIONS(1), + [anon_sym_COLON] = ACTIONS(1), + [anon_sym_LPAREN] = ACTIONS(1), + [anon_sym_RPAREN] = ACTIONS(1), + [anon_sym_SEMI] = ACTIONS(1), + [anon_sym_if] = ACTIONS(1), + [anon_sym_then] = ACTIONS(1), + [anon_sym_else] = ACTIONS(1), + [anon_sym_STAR] = ACTIONS(1), + [anon_sym_SLASH] = ACTIONS(1), + [anon_sym_PERCENT] = ACTIONS(1), + [anon_sym_PLUS] = ACTIONS(1), + [anon_sym_DASH] = ACTIONS(1), + [anon_sym_LT_LT] = ACTIONS(1), + [anon_sym_GT_GT] = ACTIONS(1), + [anon_sym_LT] = ACTIONS(1), + [anon_sym_LT_EQ] = ACTIONS(1), + [anon_sym_GT] = ACTIONS(1), + [anon_sym_GT_EQ] = ACTIONS(1), + [anon_sym_in] = ACTIONS(1), + [anon_sym_EQ_EQ] = ACTIONS(1), + [anon_sym_BANG_EQ] = ACTIONS(1), + [sym_bitand] = ACTIONS(1), + [sym_bitxor] = ACTIONS(1), + [sym_bitor] = ACTIONS(1), + [sym_and] = ACTIONS(1), + [sym_or] = ACTIONS(1), + [anon_sym_BANG] = ACTIONS(1), + [anon_sym_TILDE] = ACTIONS(1), + [anon_sym_function] = ACTIONS(1), + [anon_sym_import] = ACTIONS(1), + [anon_sym_importstr] = ACTIONS(1), + [anon_sym_error] = ACTIONS(1), + [anon_sym_COLON_COLON] = ACTIONS(1), + [anon_sym_COLON_COLON_COLON] = ACTIONS(1), + [anon_sym_for] = ACTIONS(1), + [anon_sym_assert] = ACTIONS(1), + [anon_sym_EQ] = ACTIONS(1), + [sym__number] = ACTIONS(1), + [anon_sym_AT] = ACTIONS(1), + [sym__single] = ACTIONS(1), + [sym__double] = ACTIONS(1), + [sym_escape_sequence] = ACTIONS(1), + [sym__string_start] = ACTIONS(1), + [sym__string_content] = ACTIONS(1), + [sym__string_end] = ACTIONS(1), + }, + [1] = { + [sym_document] = STATE(368), + [sym__expr] = STATE(189), + [sym_number] = STATE(189), + [sym_string] = STATE(189), + [sym_object] = STATE(189), + [sym_array] = STATE(189), + [sym_forloop] = STATE(189), + [sym_fieldaccess] = STATE(189), + [sym_indexing] = STATE(189), + [sym_fieldaccess_super] = STATE(189), + [sym_indexing_super] = STATE(189), + [sym_functioncall] = STATE(189), + [sym_id] = STATE(189), + [sym_local_bind] = STATE(189), + [sym_conditional] = STATE(189), + [sym_binary] = STATE(189), + [sym_unary] = STATE(189), + [sym_unaryop] = STATE(32), + [sym_implicit_plus] = STATE(189), + [sym_anonymous_function] = STATE(189), + [sym__assert_expr] = STATE(189), + [sym_import] = STATE(189), + [sym_importstr] = STATE(189), + [sym_error] = STATE(189), + [sym_in_super] = STATE(189), + [sym_parenthesis] = STATE(189), + [sym_assert] = STATE(367), + [sym__string] = STATE(195), + [sym__ident] = ACTIONS(5), + [sym_comment] = ACTIONS(3), + [sym_null] = ACTIONS(7), + [sym_true] = ACTIONS(7), + [sym_false] = ACTIONS(7), + [sym_self] = ACTIONS(7), + [sym_dollar] = ACTIONS(9), + [sym_super] = ACTIONS(11), + [sym_local] = ACTIONS(13), + [anon_sym_LBRACE] = ACTIONS(15), + [anon_sym_LBRACK] = ACTIONS(17), + [anon_sym_LPAREN] = ACTIONS(19), + [anon_sym_if] = ACTIONS(21), + [anon_sym_PLUS] = ACTIONS(23), + [anon_sym_DASH] = ACTIONS(23), + [anon_sym_BANG] = ACTIONS(25), + [anon_sym_TILDE] = ACTIONS(25), + [anon_sym_function] = ACTIONS(27), + [anon_sym_import] = ACTIONS(29), + [anon_sym_importstr] = ACTIONS(31), + [anon_sym_error] = ACTIONS(33), + [anon_sym_assert] = ACTIONS(35), + [sym__number] = ACTIONS(37), + [anon_sym_AT] = ACTIONS(39), + [sym__single] = ACTIONS(41), + [sym__double] = ACTIONS(43), + [sym__string_start] = ACTIONS(45), + }, +}; + +static const uint16_t ts_small_parse_table[] = { + [0] = 29, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(51), 1, + sym_dollar, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(61), 1, + anon_sym_RBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(75), 1, + anon_sym_for, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(257), 1, + sym_forspec, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(49), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(149), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [116] = 29, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(51), 1, + sym_dollar, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(75), 1, + anon_sym_for, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(87), 1, + anon_sym_RBRACK, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(255), 1, + sym_forspec, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(49), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(149), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [232] = 30, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(91), 1, + sym_dollar, + ACTIONS(93), 1, + anon_sym_RPAREN, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(204), 1, + sym_id, + STATE(331), 1, + sym_named_argument, + STATE(354), 1, + sym_assert, + STATE(369), 1, + sym_args, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(89), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(125), 23, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [350] = 30, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(91), 1, + sym_dollar, + ACTIONS(95), 1, + anon_sym_RPAREN, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(204), 1, + sym_id, + STATE(331), 1, + sym_named_argument, + STATE(354), 1, + sym_assert, + STATE(363), 1, + sym_args, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(89), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(125), 23, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [468] = 28, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(99), 1, + sym_dollar, + ACTIONS(101), 1, + anon_sym_RBRACK, + ACTIONS(103), 1, + anon_sym_COLON, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(97), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(179), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [581] = 28, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(107), 1, + sym_dollar, + ACTIONS(109), 1, + anon_sym_RBRACK, + ACTIONS(111), 1, + anon_sym_COLON, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(105), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(174), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [694] = 28, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(115), 1, + sym_dollar, + ACTIONS(117), 1, + anon_sym_RBRACK, + ACTIONS(119), 1, + anon_sym_COLON, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(113), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(166), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [807] = 28, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(123), 1, + sym_dollar, + ACTIONS(125), 1, + anon_sym_RBRACK, + ACTIONS(127), 1, + anon_sym_COLON, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(121), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(177), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [920] = 29, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(51), 1, + sym_dollar, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(129), 1, + anon_sym_RPAREN, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(204), 1, + sym_id, + STATE(344), 1, + sym_named_argument, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(49), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(149), 23, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [1035] = 28, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(133), 1, + sym_dollar, + ACTIONS(135), 1, + anon_sym_RBRACK, + ACTIONS(137), 1, + anon_sym_COLON, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(131), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(171), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [1148] = 28, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(141), 1, + sym_dollar, + ACTIONS(143), 1, + anon_sym_RBRACK, + ACTIONS(145), 1, + anon_sym_COLON, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(139), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(172), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [1261] = 29, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(51), 1, + sym_dollar, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(147), 1, + anon_sym_RPAREN, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(204), 1, + sym_id, + STATE(344), 1, + sym_named_argument, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(49), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(149), 23, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [1376] = 27, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(151), 1, + sym_dollar, + ACTIONS(153), 1, + anon_sym_RBRACK, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(149), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(103), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [1486] = 27, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(157), 1, + sym_dollar, + ACTIONS(159), 1, + anon_sym_RBRACK, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(155), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(105), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [1596] = 27, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(163), 1, + sym_dollar, + ACTIONS(165), 1, + anon_sym_RBRACK, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(161), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(187), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [1706] = 27, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(169), 1, + sym_dollar, + ACTIONS(171), 1, + anon_sym_RBRACK, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(167), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(188), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [1816] = 27, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(175), 1, + sym_dollar, + ACTIONS(177), 1, + anon_sym_RBRACK, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(173), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(191), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [1926] = 27, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(181), 1, + sym_dollar, + ACTIONS(183), 1, + anon_sym_RBRACK, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(179), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(193), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [2036] = 27, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(135), 1, + anon_sym_RBRACK, + ACTIONS(187), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(185), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(190), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [2146] = 27, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(51), 1, + sym_dollar, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(189), 1, + anon_sym_RBRACK, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(49), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(149), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [2256] = 27, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(101), 1, + anon_sym_RBRACK, + ACTIONS(193), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(191), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(182), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [2366] = 27, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(51), 1, + sym_dollar, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(195), 1, + anon_sym_RBRACK, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(49), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(149), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [2476] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(199), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(197), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(98), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [2583] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(203), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(201), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(84), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [2690] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(5), 1, + sym__ident, + ACTIONS(11), 1, + sym_super, + ACTIONS(13), 1, + sym_local, + ACTIONS(15), 1, + anon_sym_LBRACE, + ACTIONS(17), 1, + anon_sym_LBRACK, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(21), 1, + anon_sym_if, + ACTIONS(27), 1, + anon_sym_function, + ACTIONS(29), 1, + anon_sym_import, + ACTIONS(31), 1, + anon_sym_importstr, + ACTIONS(33), 1, + anon_sym_error, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(37), 1, + sym__number, + ACTIONS(39), 1, + anon_sym_AT, + ACTIONS(41), 1, + sym__single, + ACTIONS(43), 1, + sym__double, + ACTIONS(45), 1, + sym__string_start, + ACTIONS(207), 1, + sym_dollar, + STATE(32), 1, + sym_unaryop, + STATE(195), 1, + sym__string, + STATE(367), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(205), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(175), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [2797] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(211), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(209), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(184), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [2904] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(215), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(213), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(134), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [3011] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(5), 1, + sym__ident, + ACTIONS(11), 1, + sym_super, + ACTIONS(13), 1, + sym_local, + ACTIONS(15), 1, + anon_sym_LBRACE, + ACTIONS(17), 1, + anon_sym_LBRACK, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(21), 1, + anon_sym_if, + ACTIONS(27), 1, + anon_sym_function, + ACTIONS(29), 1, + anon_sym_import, + ACTIONS(31), 1, + anon_sym_importstr, + ACTIONS(33), 1, + anon_sym_error, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(37), 1, + sym__number, + ACTIONS(39), 1, + anon_sym_AT, + ACTIONS(41), 1, + sym__single, + ACTIONS(43), 1, + sym__double, + ACTIONS(45), 1, + sym__string_start, + ACTIONS(219), 1, + sym_dollar, + STATE(32), 1, + sym_unaryop, + STATE(195), 1, + sym__string, + STATE(367), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(217), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(162), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [3118] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(223), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(221), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(132), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [3225] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(227), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(225), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(154), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [3332] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(5), 1, + sym__ident, + ACTIONS(11), 1, + sym_super, + ACTIONS(13), 1, + sym_local, + ACTIONS(15), 1, + anon_sym_LBRACE, + ACTIONS(17), 1, + anon_sym_LBRACK, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(21), 1, + anon_sym_if, + ACTIONS(27), 1, + anon_sym_function, + ACTIONS(29), 1, + anon_sym_import, + ACTIONS(31), 1, + anon_sym_importstr, + ACTIONS(33), 1, + anon_sym_error, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(37), 1, + sym__number, + ACTIONS(39), 1, + anon_sym_AT, + ACTIONS(41), 1, + sym__single, + ACTIONS(43), 1, + sym__double, + ACTIONS(45), 1, + sym__string_start, + ACTIONS(231), 1, + sym_dollar, + STATE(32), 1, + sym_unaryop, + STATE(195), 1, + sym__string, + STATE(367), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(229), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(167), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [3439] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(235), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(233), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(192), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [3546] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(239), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(237), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(181), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [3653] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(5), 1, + sym__ident, + ACTIONS(11), 1, + sym_super, + ACTIONS(13), 1, + sym_local, + ACTIONS(15), 1, + anon_sym_LBRACE, + ACTIONS(17), 1, + anon_sym_LBRACK, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(21), 1, + anon_sym_if, + ACTIONS(27), 1, + anon_sym_function, + ACTIONS(29), 1, + anon_sym_import, + ACTIONS(31), 1, + anon_sym_importstr, + ACTIONS(33), 1, + anon_sym_error, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(37), 1, + sym__number, + ACTIONS(39), 1, + anon_sym_AT, + ACTIONS(41), 1, + sym__single, + ACTIONS(43), 1, + sym__double, + ACTIONS(45), 1, + sym__string_start, + ACTIONS(243), 1, + sym_dollar, + STATE(32), 1, + sym_unaryop, + STATE(195), 1, + sym__string, + STATE(367), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(241), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(170), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [3760] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(5), 1, + sym__ident, + ACTIONS(11), 1, + sym_super, + ACTIONS(13), 1, + sym_local, + ACTIONS(15), 1, + anon_sym_LBRACE, + ACTIONS(17), 1, + anon_sym_LBRACK, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(21), 1, + anon_sym_if, + ACTIONS(27), 1, + anon_sym_function, + ACTIONS(29), 1, + anon_sym_import, + ACTIONS(31), 1, + anon_sym_importstr, + ACTIONS(33), 1, + anon_sym_error, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(37), 1, + sym__number, + ACTIONS(39), 1, + anon_sym_AT, + ACTIONS(41), 1, + sym__single, + ACTIONS(43), 1, + sym__double, + ACTIONS(45), 1, + sym__string_start, + ACTIONS(247), 1, + sym_dollar, + STATE(32), 1, + sym_unaryop, + STATE(195), 1, + sym__string, + STATE(367), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(245), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(153), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [3867] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(251), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(249), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(169), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [3974] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(255), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(253), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(89), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [4081] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(259), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(257), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(94), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [4188] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(5), 1, + sym__ident, + ACTIONS(11), 1, + sym_super, + ACTIONS(13), 1, + sym_local, + ACTIONS(15), 1, + anon_sym_LBRACE, + ACTIONS(17), 1, + anon_sym_LBRACK, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(21), 1, + anon_sym_if, + ACTIONS(27), 1, + anon_sym_function, + ACTIONS(29), 1, + anon_sym_import, + ACTIONS(31), 1, + anon_sym_importstr, + ACTIONS(33), 1, + anon_sym_error, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(37), 1, + sym__number, + ACTIONS(39), 1, + anon_sym_AT, + ACTIONS(41), 1, + sym__single, + ACTIONS(43), 1, + sym__double, + ACTIONS(45), 1, + sym__string_start, + ACTIONS(263), 1, + sym_dollar, + STATE(32), 1, + sym_unaryop, + STATE(195), 1, + sym__string, + STATE(367), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(261), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(178), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [4295] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(51), 1, + sym_dollar, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(49), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(149), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [4402] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(267), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(265), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(86), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [4509] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(271), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(269), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(151), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [4616] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(275), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(273), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(147), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [4723] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(279), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(277), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(135), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [4830] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(283), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(281), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(185), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [4937] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(287), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(285), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(93), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [5044] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(291), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(289), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(118), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [5151] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(295), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(293), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(152), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [5258] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(299), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(297), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(101), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [5365] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(303), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(301), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(148), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [5472] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(5), 1, + sym__ident, + ACTIONS(11), 1, + sym_super, + ACTIONS(13), 1, + sym_local, + ACTIONS(15), 1, + anon_sym_LBRACE, + ACTIONS(17), 1, + anon_sym_LBRACK, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(21), 1, + anon_sym_if, + ACTIONS(27), 1, + anon_sym_function, + ACTIONS(29), 1, + anon_sym_import, + ACTIONS(31), 1, + anon_sym_importstr, + ACTIONS(33), 1, + anon_sym_error, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(37), 1, + sym__number, + ACTIONS(39), 1, + anon_sym_AT, + ACTIONS(41), 1, + sym__single, + ACTIONS(43), 1, + sym__double, + ACTIONS(45), 1, + sym__string_start, + ACTIONS(307), 1, + sym_dollar, + STATE(32), 1, + sym_unaryop, + STATE(195), 1, + sym__string, + STATE(367), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(305), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(173), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [5579] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(311), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(309), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(100), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [5686] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(315), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(313), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(85), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [5793] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(319), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(317), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(150), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [5900] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(323), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(321), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(96), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [6007] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(327), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(325), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(83), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [6114] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(331), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(329), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(186), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [6221] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(335), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(333), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(92), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [6328] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(339), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(337), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(131), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [6435] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(343), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(341), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(97), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [6542] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(5), 1, + sym__ident, + ACTIONS(11), 1, + sym_super, + ACTIONS(13), 1, + sym_local, + ACTIONS(15), 1, + anon_sym_LBRACE, + ACTIONS(17), 1, + anon_sym_LBRACK, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(21), 1, + anon_sym_if, + ACTIONS(27), 1, + anon_sym_function, + ACTIONS(29), 1, + anon_sym_import, + ACTIONS(31), 1, + anon_sym_importstr, + ACTIONS(33), 1, + anon_sym_error, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(37), 1, + sym__number, + ACTIONS(39), 1, + anon_sym_AT, + ACTIONS(41), 1, + sym__single, + ACTIONS(43), 1, + sym__double, + ACTIONS(45), 1, + sym__string_start, + ACTIONS(347), 1, + sym_dollar, + STATE(32), 1, + sym_unaryop, + STATE(195), 1, + sym__string, + STATE(367), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(345), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(168), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [6649] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(351), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(349), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(144), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [6756] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(355), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(353), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(95), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [6863] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(359), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(357), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(194), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [6970] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(363), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(361), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(91), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [7077] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(5), 1, + sym__ident, + ACTIONS(11), 1, + sym_super, + ACTIONS(13), 1, + sym_local, + ACTIONS(15), 1, + anon_sym_LBRACE, + ACTIONS(17), 1, + anon_sym_LBRACK, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(21), 1, + anon_sym_if, + ACTIONS(27), 1, + anon_sym_function, + ACTIONS(29), 1, + anon_sym_import, + ACTIONS(31), 1, + anon_sym_importstr, + ACTIONS(33), 1, + anon_sym_error, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(37), 1, + sym__number, + ACTIONS(39), 1, + anon_sym_AT, + ACTIONS(41), 1, + sym__single, + ACTIONS(43), 1, + sym__double, + ACTIONS(45), 1, + sym__string_start, + ACTIONS(367), 1, + sym_dollar, + STATE(32), 1, + sym_unaryop, + STATE(195), 1, + sym__string, + STATE(367), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(365), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(164), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [7184] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(5), 1, + sym__ident, + ACTIONS(11), 1, + sym_super, + ACTIONS(13), 1, + sym_local, + ACTIONS(15), 1, + anon_sym_LBRACE, + ACTIONS(17), 1, + anon_sym_LBRACK, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(21), 1, + anon_sym_if, + ACTIONS(27), 1, + anon_sym_function, + ACTIONS(29), 1, + anon_sym_import, + ACTIONS(31), 1, + anon_sym_importstr, + ACTIONS(33), 1, + anon_sym_error, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(37), 1, + sym__number, + ACTIONS(39), 1, + anon_sym_AT, + ACTIONS(41), 1, + sym__single, + ACTIONS(43), 1, + sym__double, + ACTIONS(45), 1, + sym__string_start, + ACTIONS(371), 1, + sym_dollar, + STATE(32), 1, + sym_unaryop, + STATE(195), 1, + sym__string, + STATE(367), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(369), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(163), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [7291] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(5), 1, + sym__ident, + ACTIONS(11), 1, + sym_super, + ACTIONS(13), 1, + sym_local, + ACTIONS(15), 1, + anon_sym_LBRACE, + ACTIONS(17), 1, + anon_sym_LBRACK, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(21), 1, + anon_sym_if, + ACTIONS(27), 1, + anon_sym_function, + ACTIONS(29), 1, + anon_sym_import, + ACTIONS(31), 1, + anon_sym_importstr, + ACTIONS(33), 1, + anon_sym_error, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(37), 1, + sym__number, + ACTIONS(39), 1, + anon_sym_AT, + ACTIONS(41), 1, + sym__single, + ACTIONS(43), 1, + sym__double, + ACTIONS(45), 1, + sym__string_start, + ACTIONS(375), 1, + sym_dollar, + STATE(32), 1, + sym_unaryop, + STATE(195), 1, + sym__string, + STATE(367), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(373), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(161), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [7398] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(5), 1, + sym__ident, + ACTIONS(11), 1, + sym_super, + ACTIONS(13), 1, + sym_local, + ACTIONS(15), 1, + anon_sym_LBRACE, + ACTIONS(17), 1, + anon_sym_LBRACK, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(21), 1, + anon_sym_if, + ACTIONS(27), 1, + anon_sym_function, + ACTIONS(29), 1, + anon_sym_import, + ACTIONS(31), 1, + anon_sym_importstr, + ACTIONS(33), 1, + anon_sym_error, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(37), 1, + sym__number, + ACTIONS(39), 1, + anon_sym_AT, + ACTIONS(41), 1, + sym__single, + ACTIONS(43), 1, + sym__double, + ACTIONS(45), 1, + sym__string_start, + ACTIONS(379), 1, + sym_dollar, + STATE(32), 1, + sym_unaryop, + STATE(195), 1, + sym__string, + STATE(367), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(377), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(160), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [7505] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(5), 1, + sym__ident, + ACTIONS(11), 1, + sym_super, + ACTIONS(13), 1, + sym_local, + ACTIONS(15), 1, + anon_sym_LBRACE, + ACTIONS(17), 1, + anon_sym_LBRACK, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(21), 1, + anon_sym_if, + ACTIONS(27), 1, + anon_sym_function, + ACTIONS(29), 1, + anon_sym_import, + ACTIONS(31), 1, + anon_sym_importstr, + ACTIONS(33), 1, + anon_sym_error, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(37), 1, + sym__number, + ACTIONS(39), 1, + anon_sym_AT, + ACTIONS(41), 1, + sym__single, + ACTIONS(43), 1, + sym__double, + ACTIONS(45), 1, + sym__string_start, + ACTIONS(383), 1, + sym_dollar, + STATE(32), 1, + sym_unaryop, + STATE(195), 1, + sym__string, + STATE(367), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(381), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(159), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [7612] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(387), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(385), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(99), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [7719] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(5), 1, + sym__ident, + ACTIONS(11), 1, + sym_super, + ACTIONS(13), 1, + sym_local, + ACTIONS(15), 1, + anon_sym_LBRACE, + ACTIONS(17), 1, + anon_sym_LBRACK, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(21), 1, + anon_sym_if, + ACTIONS(27), 1, + anon_sym_function, + ACTIONS(29), 1, + anon_sym_import, + ACTIONS(31), 1, + anon_sym_importstr, + ACTIONS(33), 1, + anon_sym_error, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(37), 1, + sym__number, + ACTIONS(39), 1, + anon_sym_AT, + ACTIONS(41), 1, + sym__single, + ACTIONS(43), 1, + sym__double, + ACTIONS(45), 1, + sym__string_start, + ACTIONS(391), 1, + sym_dollar, + STATE(32), 1, + sym_unaryop, + STATE(195), 1, + sym__string, + STATE(367), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(389), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(158), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [7826] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(5), 1, + sym__ident, + ACTIONS(11), 1, + sym_super, + ACTIONS(13), 1, + sym_local, + ACTIONS(15), 1, + anon_sym_LBRACE, + ACTIONS(17), 1, + anon_sym_LBRACK, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(21), 1, + anon_sym_if, + ACTIONS(27), 1, + anon_sym_function, + ACTIONS(29), 1, + anon_sym_import, + ACTIONS(31), 1, + anon_sym_importstr, + ACTIONS(33), 1, + anon_sym_error, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(37), 1, + sym__number, + ACTIONS(39), 1, + anon_sym_AT, + ACTIONS(41), 1, + sym__single, + ACTIONS(43), 1, + sym__double, + ACTIONS(45), 1, + sym__string_start, + ACTIONS(395), 1, + sym_dollar, + STATE(32), 1, + sym_unaryop, + STATE(195), 1, + sym__string, + STATE(367), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(393), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(157), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [7933] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(5), 1, + sym__ident, + ACTIONS(11), 1, + sym_super, + ACTIONS(13), 1, + sym_local, + ACTIONS(15), 1, + anon_sym_LBRACE, + ACTIONS(17), 1, + anon_sym_LBRACK, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(21), 1, + anon_sym_if, + ACTIONS(27), 1, + anon_sym_function, + ACTIONS(29), 1, + anon_sym_import, + ACTIONS(31), 1, + anon_sym_importstr, + ACTIONS(33), 1, + anon_sym_error, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(37), 1, + sym__number, + ACTIONS(39), 1, + anon_sym_AT, + ACTIONS(41), 1, + sym__single, + ACTIONS(43), 1, + sym__double, + ACTIONS(45), 1, + sym__string_start, + ACTIONS(399), 1, + sym_dollar, + STATE(32), 1, + sym_unaryop, + STATE(195), 1, + sym__string, + STATE(367), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(397), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(156), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [8040] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(5), 1, + sym__ident, + ACTIONS(11), 1, + sym_super, + ACTIONS(13), 1, + sym_local, + ACTIONS(15), 1, + anon_sym_LBRACE, + ACTIONS(17), 1, + anon_sym_LBRACK, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(21), 1, + anon_sym_if, + ACTIONS(27), 1, + anon_sym_function, + ACTIONS(29), 1, + anon_sym_import, + ACTIONS(31), 1, + anon_sym_importstr, + ACTIONS(33), 1, + anon_sym_error, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(37), 1, + sym__number, + ACTIONS(39), 1, + anon_sym_AT, + ACTIONS(41), 1, + sym__single, + ACTIONS(43), 1, + sym__double, + ACTIONS(45), 1, + sym__string_start, + ACTIONS(403), 1, + sym_dollar, + STATE(32), 1, + sym_unaryop, + STATE(195), 1, + sym__string, + STATE(367), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(401), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(155), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [8147] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(5), 1, + sym__ident, + ACTIONS(11), 1, + sym_super, + ACTIONS(13), 1, + sym_local, + ACTIONS(15), 1, + anon_sym_LBRACE, + ACTIONS(17), 1, + anon_sym_LBRACK, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(21), 1, + anon_sym_if, + ACTIONS(27), 1, + anon_sym_function, + ACTIONS(29), 1, + anon_sym_import, + ACTIONS(31), 1, + anon_sym_importstr, + ACTIONS(33), 1, + anon_sym_error, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(37), 1, + sym__number, + ACTIONS(39), 1, + anon_sym_AT, + ACTIONS(41), 1, + sym__single, + ACTIONS(43), 1, + sym__double, + ACTIONS(45), 1, + sym__string_start, + ACTIONS(407), 1, + sym_dollar, + STATE(32), 1, + sym_unaryop, + STATE(195), 1, + sym__string, + STATE(367), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(405), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(176), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [8254] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(411), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(409), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(90), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [8361] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(5), 1, + sym__ident, + ACTIONS(11), 1, + sym_super, + ACTIONS(13), 1, + sym_local, + ACTIONS(15), 1, + anon_sym_LBRACE, + ACTIONS(17), 1, + anon_sym_LBRACK, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(21), 1, + anon_sym_if, + ACTIONS(27), 1, + anon_sym_function, + ACTIONS(29), 1, + anon_sym_import, + ACTIONS(31), 1, + anon_sym_importstr, + ACTIONS(33), 1, + anon_sym_error, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(37), 1, + sym__number, + ACTIONS(39), 1, + anon_sym_AT, + ACTIONS(41), 1, + sym__single, + ACTIONS(43), 1, + sym__double, + ACTIONS(45), 1, + sym__string_start, + ACTIONS(415), 1, + sym_dollar, + STATE(32), 1, + sym_unaryop, + STATE(195), 1, + sym__string, + STATE(367), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(413), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(180), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [8468] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(419), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(417), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(183), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [8575] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(423), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(421), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(88), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [8682] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(47), 1, + sym__ident, + ACTIONS(53), 1, + sym_super, + ACTIONS(55), 1, + sym_local, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(59), 1, + anon_sym_LBRACK, + ACTIONS(63), 1, + anon_sym_LPAREN, + ACTIONS(65), 1, + anon_sym_if, + ACTIONS(67), 1, + anon_sym_function, + ACTIONS(69), 1, + anon_sym_import, + ACTIONS(71), 1, + anon_sym_importstr, + ACTIONS(73), 1, + anon_sym_error, + ACTIONS(77), 1, + sym__number, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + ACTIONS(427), 1, + sym_dollar, + STATE(38), 1, + sym_unaryop, + STATE(113), 1, + sym__string, + STATE(354), 1, + sym_assert, + ACTIONS(23), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(25), 2, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(425), 4, + sym_null, + sym_true, + sym_false, + sym_self, + STATE(87), 24, + sym__expr, + sym_number, + sym_string, + sym_object, + sym_array, + sym_forloop, + sym_fieldaccess, + sym_indexing, + sym_fieldaccess_super, + sym_indexing_super, + sym_functioncall, + sym_id, + sym_local_bind, + sym_conditional, + sym_binary, + sym_unary, + sym_implicit_plus, + sym_anonymous_function, + sym__assert_expr, + sym_import, + sym_importstr, + sym_error, + sym_in_super, + sym_parenthesis, + [8789] = 22, + ACTIONS(3), 1, + sym_comment, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(457), 1, + sym_bitor, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(429), 13, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + sym_and, + sym_or, + anon_sym_for, + [8874] = 12, + ACTIONS(3), 1, + sym_comment, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(457), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(429), 25, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [8939] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(459), 10, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_for, + [9030] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(467), 10, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_for, + [9121] = 19, + ACTIONS(3), 1, + sym_comment, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(457), 2, + sym_bitand, + sym_bitor, + ACTIONS(429), 16, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [9200] = 16, + ACTIONS(3), 1, + sym_comment, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(457), 4, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(429), 19, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [9273] = 12, + ACTIONS(3), 1, + sym_comment, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(471), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(469), 25, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [9338] = 15, + ACTIONS(3), 1, + sym_comment, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(457), 4, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(429), 21, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [9409] = 14, + ACTIONS(3), 1, + sym_comment, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(457), 4, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(429), 23, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [9478] = 22, + ACTIONS(3), 1, + sym_comment, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(429), 13, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + sym_and, + sym_or, + anon_sym_for, + [9563] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(473), 10, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_for, + [9654] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + ACTIONS(477), 1, + anon_sym_else, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(475), 9, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_for, + [9747] = 23, + ACTIONS(3), 1, + sym_comment, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(429), 12, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + sym_or, + anon_sym_for, + [9834] = 21, + ACTIONS(3), 1, + sym_comment, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(457), 1, + sym_bitor, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(429), 14, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [9917] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(479), 10, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_for, + [10008] = 20, + ACTIONS(3), 1, + sym_comment, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(457), 2, + sym_bitand, + sym_bitor, + ACTIONS(429), 14, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [10089] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(481), 10, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_for, + [10180] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(483), 10, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_for, + [10271] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(485), 10, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_for, + [10362] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(487), 1, + sym_tailstrict, + ACTIONS(491), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(489), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [10406] = 29, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + ACTIONS(493), 1, + anon_sym_COMMA, + ACTIONS(495), 1, + anon_sym_RBRACK, + ACTIONS(497), 1, + anon_sym_for, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + STATE(254), 1, + sym_forspec, + STATE(321), 1, + aux_sym_array_repeat1, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [10500] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(499), 1, + sym_tailstrict, + ACTIONS(503), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(501), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [10544] = 29, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + ACTIONS(497), 1, + anon_sym_for, + ACTIONS(505), 1, + anon_sym_COMMA, + ACTIONS(507), 1, + anon_sym_RBRACK, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + STATE(258), 1, + sym_forspec, + STATE(323), 1, + aux_sym_array_repeat1, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [10638] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(511), 6, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + anon_sym_EQ, + ACTIONS(509), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [10680] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(515), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(513), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [10721] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(519), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(517), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [10762] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(523), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(521), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [10803] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(527), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(525), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [10844] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(531), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(529), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [10885] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(535), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(533), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [10926] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(539), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(537), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [10967] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(543), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(541), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [11008] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(547), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(545), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [11049] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(551), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(549), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [11090] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(555), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(553), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [11131] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(557), 4, + anon_sym_RBRACE, + anon_sym_RBRACK, + anon_sym_if, + anon_sym_for, + [11216] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(561), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(559), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [11257] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(565), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(563), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [11298] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(569), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(567), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [11339] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(573), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(571), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [11380] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(577), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(575), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [11421] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(581), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(579), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [11462] = 28, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + ACTIONS(583), 1, + anon_sym_COMMA, + ACTIONS(585), 1, + anon_sym_RPAREN, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + STATE(277), 1, + aux_sym_array_repeat1, + STATE(311), 1, + aux_sym_args_repeat1, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [11553] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(589), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(587), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [11594] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(593), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(591), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [11635] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(597), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(595), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [11676] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(601), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(599), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [11717] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(605), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(603), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [11758] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(607), 4, + anon_sym_RBRACE, + anon_sym_RBRACK, + anon_sym_if, + anon_sym_for, + [11843] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + ACTIONS(611), 1, + anon_sym_COLON, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(609), 3, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_SEMI, + [11930] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(615), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(613), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [11971] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(617), 4, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_for, + [12056] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(619), 4, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_for, + [12141] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(623), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(621), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [12182] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(627), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(625), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [12223] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(631), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(629), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [12264] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(635), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(633), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [12305] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(639), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(637), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [12346] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(643), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(641), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [12387] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(647), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(645), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [12428] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(491), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(489), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [12469] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(649), 4, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_for, + [12554] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(653), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(651), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [12595] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(657), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(655), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_DOT, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_if, + anon_sym_then, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_for, + [12636] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(659), 3, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_for, + [12720] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(661), 3, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_SEMI, + [12804] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(663), 3, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + [12888] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(665), 3, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_for, + [12972] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(667), 3, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_for, + [13056] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(669), 3, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_for, + [13140] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(15), 1, + anon_sym_LBRACE, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(475), 1, + ts_builtin_sym_end, + ACTIONS(671), 1, + anon_sym_LBRACK, + ACTIONS(673), 1, + anon_sym_DOT, + ACTIONS(675), 1, + anon_sym_LPAREN, + ACTIONS(677), 1, + anon_sym_else, + ACTIONS(679), 1, + anon_sym_in, + ACTIONS(681), 1, + sym_bitand, + ACTIONS(683), 1, + sym_bitxor, + ACTIONS(685), 1, + sym_bitor, + ACTIONS(687), 1, + sym_and, + ACTIONS(689), 1, + sym_or, + STATE(73), 1, + sym_multiplicative, + STATE(74), 1, + sym_additive, + STATE(75), 1, + sym_bitshift, + STATE(76), 1, + sym_comparison, + STATE(77), 1, + sym_equality, + STATE(212), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [13225] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(691), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + [13308] = 16, + ACTIONS(3), 1, + sym_comment, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(671), 1, + anon_sym_LBRACK, + ACTIONS(673), 1, + anon_sym_DOT, + ACTIONS(675), 1, + anon_sym_LPAREN, + STATE(73), 1, + sym_multiplicative, + STATE(74), 1, + sym_additive, + STATE(75), 1, + sym_bitshift, + STATE(76), 1, + sym_comparison, + STATE(77), 1, + sym_equality, + STATE(212), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(457), 4, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(429), 11, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_else, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [13373] = 15, + ACTIONS(3), 1, + sym_comment, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(671), 1, + anon_sym_LBRACK, + ACTIONS(673), 1, + anon_sym_DOT, + ACTIONS(675), 1, + anon_sym_LPAREN, + STATE(73), 1, + sym_multiplicative, + STATE(74), 1, + sym_additive, + STATE(75), 1, + sym_bitshift, + STATE(76), 1, + sym_comparison, + STATE(77), 1, + sym_equality, + STATE(212), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(457), 4, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(429), 13, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_else, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [13436] = 14, + ACTIONS(3), 1, + sym_comment, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(671), 1, + anon_sym_LBRACK, + ACTIONS(673), 1, + anon_sym_DOT, + ACTIONS(675), 1, + anon_sym_LPAREN, + STATE(73), 1, + sym_multiplicative, + STATE(74), 1, + sym_additive, + STATE(75), 1, + sym_bitshift, + STATE(76), 1, + sym_comparison, + STATE(77), 1, + sym_equality, + STATE(212), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(457), 4, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(429), 15, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_else, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [13497] = 12, + ACTIONS(3), 1, + sym_comment, + ACTIONS(671), 1, + anon_sym_LBRACK, + ACTIONS(673), 1, + anon_sym_DOT, + ACTIONS(675), 1, + anon_sym_LPAREN, + STATE(73), 1, + sym_multiplicative, + STATE(74), 1, + sym_additive, + STATE(75), 1, + sym_bitshift, + STATE(76), 1, + sym_comparison, + STATE(77), 1, + sym_equality, + STATE(212), 1, + sym_object, + ACTIONS(457), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(429), 17, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [13554] = 23, + ACTIONS(3), 1, + sym_comment, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(671), 1, + anon_sym_LBRACK, + ACTIONS(673), 1, + anon_sym_DOT, + ACTIONS(675), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, + anon_sym_in, + ACTIONS(681), 1, + sym_bitand, + ACTIONS(683), 1, + sym_bitxor, + ACTIONS(685), 1, + sym_bitor, + ACTIONS(687), 1, + sym_and, + STATE(73), 1, + sym_multiplicative, + STATE(74), 1, + sym_additive, + STATE(75), 1, + sym_bitshift, + STATE(76), 1, + sym_comparison, + STATE(77), 1, + sym_equality, + STATE(212), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(429), 4, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_else, + sym_or, + [13633] = 22, + ACTIONS(3), 1, + sym_comment, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(671), 1, + anon_sym_LBRACK, + ACTIONS(673), 1, + anon_sym_DOT, + ACTIONS(675), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, + anon_sym_in, + ACTIONS(681), 1, + sym_bitand, + ACTIONS(683), 1, + sym_bitxor, + ACTIONS(685), 1, + sym_bitor, + STATE(73), 1, + sym_multiplicative, + STATE(74), 1, + sym_additive, + STATE(75), 1, + sym_bitshift, + STATE(76), 1, + sym_comparison, + STATE(77), 1, + sym_equality, + STATE(212), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(429), 5, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_else, + sym_and, + sym_or, + [13710] = 22, + ACTIONS(3), 1, + sym_comment, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(457), 1, + sym_bitor, + ACTIONS(671), 1, + anon_sym_LBRACK, + ACTIONS(673), 1, + anon_sym_DOT, + ACTIONS(675), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, + anon_sym_in, + ACTIONS(681), 1, + sym_bitand, + ACTIONS(683), 1, + sym_bitxor, + STATE(73), 1, + sym_multiplicative, + STATE(74), 1, + sym_additive, + STATE(75), 1, + sym_bitshift, + STATE(76), 1, + sym_comparison, + STATE(77), 1, + sym_equality, + STATE(212), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(429), 5, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_else, + sym_and, + sym_or, + [13787] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(15), 1, + anon_sym_LBRACE, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(671), 1, + anon_sym_LBRACK, + ACTIONS(673), 1, + anon_sym_DOT, + ACTIONS(675), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, + anon_sym_in, + ACTIONS(681), 1, + sym_bitand, + ACTIONS(683), 1, + sym_bitxor, + ACTIONS(685), 1, + sym_bitor, + ACTIONS(687), 1, + sym_and, + ACTIONS(689), 1, + sym_or, + STATE(73), 1, + sym_multiplicative, + STATE(74), 1, + sym_additive, + STATE(75), 1, + sym_bitshift, + STATE(76), 1, + sym_comparison, + STATE(77), 1, + sym_equality, + STATE(212), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(485), 2, + ts_builtin_sym_end, + anon_sym_else, + [13870] = 21, + ACTIONS(3), 1, + sym_comment, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(457), 1, + sym_bitor, + ACTIONS(671), 1, + anon_sym_LBRACK, + ACTIONS(673), 1, + anon_sym_DOT, + ACTIONS(675), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, + anon_sym_in, + ACTIONS(681), 1, + sym_bitand, + STATE(73), 1, + sym_multiplicative, + STATE(74), 1, + sym_additive, + STATE(75), 1, + sym_bitshift, + STATE(76), 1, + sym_comparison, + STATE(77), 1, + sym_equality, + STATE(212), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(429), 6, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_else, + sym_bitxor, + sym_and, + sym_or, + [13945] = 20, + ACTIONS(3), 1, + sym_comment, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(671), 1, + anon_sym_LBRACK, + ACTIONS(673), 1, + anon_sym_DOT, + ACTIONS(675), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, + anon_sym_in, + STATE(73), 1, + sym_multiplicative, + STATE(74), 1, + sym_additive, + STATE(75), 1, + sym_bitshift, + STATE(76), 1, + sym_comparison, + STATE(77), 1, + sym_equality, + STATE(212), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(457), 2, + sym_bitand, + sym_bitor, + ACTIONS(429), 6, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_else, + sym_bitxor, + sym_and, + sym_or, + [14018] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(511), 8, + anon_sym_COLON, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + anon_sym_COLON_COLON, + anon_sym_EQ, + ACTIONS(509), 23, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_COLON_COLON_COLON, + [14057] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(101), 1, + anon_sym_RBRACK, + ACTIONS(103), 1, + anon_sym_COLON, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [14142] = 12, + ACTIONS(3), 1, + sym_comment, + ACTIONS(671), 1, + anon_sym_LBRACK, + ACTIONS(673), 1, + anon_sym_DOT, + ACTIONS(675), 1, + anon_sym_LPAREN, + STATE(73), 1, + sym_multiplicative, + STATE(74), 1, + sym_additive, + STATE(75), 1, + sym_bitshift, + STATE(76), 1, + sym_comparison, + STATE(77), 1, + sym_equality, + STATE(212), 1, + sym_object, + ACTIONS(471), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(469), 17, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [14199] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(15), 1, + anon_sym_LBRACE, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(671), 1, + anon_sym_LBRACK, + ACTIONS(673), 1, + anon_sym_DOT, + ACTIONS(675), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, + anon_sym_in, + ACTIONS(681), 1, + sym_bitand, + ACTIONS(683), 1, + sym_bitxor, + ACTIONS(685), 1, + sym_bitor, + ACTIONS(687), 1, + sym_and, + ACTIONS(689), 1, + sym_or, + STATE(73), 1, + sym_multiplicative, + STATE(74), 1, + sym_additive, + STATE(75), 1, + sym_bitshift, + STATE(76), 1, + sym_comparison, + STATE(77), 1, + sym_equality, + STATE(212), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(483), 2, + ts_builtin_sym_end, + anon_sym_else, + [14282] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(693), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + [14365] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(15), 1, + anon_sym_LBRACE, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(671), 1, + anon_sym_LBRACK, + ACTIONS(673), 1, + anon_sym_DOT, + ACTIONS(675), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, + anon_sym_in, + ACTIONS(681), 1, + sym_bitand, + ACTIONS(683), 1, + sym_bitxor, + ACTIONS(685), 1, + sym_bitor, + ACTIONS(687), 1, + sym_and, + ACTIONS(689), 1, + sym_or, + STATE(73), 1, + sym_multiplicative, + STATE(74), 1, + sym_additive, + STATE(75), 1, + sym_bitshift, + STATE(76), 1, + sym_comparison, + STATE(77), 1, + sym_equality, + STATE(212), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(479), 2, + ts_builtin_sym_end, + anon_sym_else, + [14448] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(183), 1, + anon_sym_RBRACK, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + ACTIONS(695), 1, + anon_sym_COLON, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [14533] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(117), 1, + anon_sym_RBRACK, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + ACTIONS(697), 1, + anon_sym_COLON, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [14618] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(15), 1, + anon_sym_LBRACE, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(671), 1, + anon_sym_LBRACK, + ACTIONS(673), 1, + anon_sym_DOT, + ACTIONS(675), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, + anon_sym_in, + ACTIONS(681), 1, + sym_bitand, + ACTIONS(683), 1, + sym_bitxor, + ACTIONS(685), 1, + sym_bitor, + ACTIONS(687), 1, + sym_and, + ACTIONS(689), 1, + sym_or, + STATE(73), 1, + sym_multiplicative, + STATE(74), 1, + sym_additive, + STATE(75), 1, + sym_bitshift, + STATE(76), 1, + sym_comparison, + STATE(77), 1, + sym_equality, + STATE(212), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(481), 2, + ts_builtin_sym_end, + anon_sym_else, + [14701] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(135), 1, + anon_sym_RBRACK, + ACTIONS(137), 1, + anon_sym_COLON, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [14786] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(15), 1, + anon_sym_LBRACE, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(671), 1, + anon_sym_LBRACK, + ACTIONS(673), 1, + anon_sym_DOT, + ACTIONS(675), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, + anon_sym_in, + ACTIONS(681), 1, + sym_bitand, + ACTIONS(683), 1, + sym_bitxor, + ACTIONS(685), 1, + sym_bitor, + ACTIONS(687), 1, + sym_and, + ACTIONS(689), 1, + sym_or, + STATE(73), 1, + sym_multiplicative, + STATE(74), 1, + sym_additive, + STATE(75), 1, + sym_bitshift, + STATE(76), 1, + sym_comparison, + STATE(77), 1, + sym_equality, + STATE(212), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(467), 2, + ts_builtin_sym_end, + anon_sym_else, + [14869] = 19, + ACTIONS(3), 1, + sym_comment, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(671), 1, + anon_sym_LBRACK, + ACTIONS(673), 1, + anon_sym_DOT, + ACTIONS(675), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, + anon_sym_in, + STATE(73), 1, + sym_multiplicative, + STATE(74), 1, + sym_additive, + STATE(75), 1, + sym_bitshift, + STATE(76), 1, + sym_comparison, + STATE(77), 1, + sym_equality, + STATE(212), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(457), 2, + sym_bitand, + sym_bitor, + ACTIONS(429), 8, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_else, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [14940] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(109), 1, + anon_sym_RBRACK, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + ACTIONS(699), 1, + anon_sym_COLON, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [15025] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(15), 1, + anon_sym_LBRACE, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(671), 1, + anon_sym_LBRACK, + ACTIONS(673), 1, + anon_sym_DOT, + ACTIONS(675), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, + anon_sym_in, + ACTIONS(681), 1, + sym_bitand, + ACTIONS(683), 1, + sym_bitxor, + ACTIONS(685), 1, + sym_bitor, + ACTIONS(687), 1, + sym_and, + ACTIONS(689), 1, + sym_or, + STATE(73), 1, + sym_multiplicative, + STATE(74), 1, + sym_additive, + STATE(75), 1, + sym_bitshift, + STATE(76), 1, + sym_comparison, + STATE(77), 1, + sym_equality, + STATE(212), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(473), 2, + ts_builtin_sym_end, + anon_sym_else, + [15108] = 26, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(177), 1, + anon_sym_RBRACK, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + ACTIONS(701), 1, + anon_sym_COLON, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [15193] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(15), 1, + anon_sym_LBRACE, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(671), 1, + anon_sym_LBRACK, + ACTIONS(673), 1, + anon_sym_DOT, + ACTIONS(675), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, + anon_sym_in, + ACTIONS(681), 1, + sym_bitand, + ACTIONS(683), 1, + sym_bitxor, + ACTIONS(685), 1, + sym_bitor, + ACTIONS(687), 1, + sym_and, + ACTIONS(689), 1, + sym_or, + STATE(73), 1, + sym_multiplicative, + STATE(74), 1, + sym_additive, + STATE(75), 1, + sym_bitshift, + STATE(76), 1, + sym_comparison, + STATE(77), 1, + sym_equality, + STATE(212), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(459), 2, + ts_builtin_sym_end, + anon_sym_else, + [15276] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + ACTIONS(703), 1, + anon_sym_RBRACK, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [15358] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(177), 1, + anon_sym_RBRACK, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [15440] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + ACTIONS(705), 1, + anon_sym_RPAREN, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [15522] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + ACTIONS(707), 1, + anon_sym_then, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [15604] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + ACTIONS(709), 1, + anon_sym_then, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [15686] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + ACTIONS(711), 1, + anon_sym_RBRACK, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [15768] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + ACTIONS(713), 1, + anon_sym_RBRACK, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [15850] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + ACTIONS(715), 1, + anon_sym_RBRACK, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [15932] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(15), 1, + anon_sym_LBRACE, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(671), 1, + anon_sym_LBRACK, + ACTIONS(673), 1, + anon_sym_DOT, + ACTIONS(675), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, + anon_sym_in, + ACTIONS(681), 1, + sym_bitand, + ACTIONS(683), 1, + sym_bitxor, + ACTIONS(685), 1, + sym_bitor, + ACTIONS(687), 1, + sym_and, + ACTIONS(689), 1, + sym_or, + ACTIONS(717), 1, + ts_builtin_sym_end, + STATE(73), 1, + sym_multiplicative, + STATE(74), 1, + sym_additive, + STATE(75), 1, + sym_bitshift, + STATE(76), 1, + sym_comparison, + STATE(77), 1, + sym_equality, + STATE(212), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [16014] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(183), 1, + anon_sym_RBRACK, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [16096] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(171), 1, + anon_sym_RBRACK, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [16178] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + ACTIONS(719), 1, + anon_sym_RBRACK, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [16260] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(165), 1, + anon_sym_RBRACK, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [16342] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(57), 1, + anon_sym_LBRACE, + ACTIONS(431), 1, + anon_sym_LBRACK, + ACTIONS(433), 1, + anon_sym_DOT, + ACTIONS(435), 1, + anon_sym_LPAREN, + ACTIONS(439), 1, + anon_sym_SLASH, + ACTIONS(449), 1, + anon_sym_in, + ACTIONS(453), 1, + sym_bitand, + ACTIONS(455), 1, + sym_bitxor, + ACTIONS(461), 1, + sym_bitor, + ACTIONS(463), 1, + sym_and, + ACTIONS(465), 1, + sym_or, + ACTIONS(721), 1, + anon_sym_RPAREN, + STATE(25), 1, + sym_multiplicative, + STATE(66), 1, + sym_additive, + STATE(78), 1, + sym_bitshift, + STATE(81), 1, + sym_comparison, + STATE(82), 1, + sym_equality, + STATE(127), 1, + sym_object, + ACTIONS(437), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(441), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(443), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(445), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(447), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(451), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [16424] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(539), 7, + anon_sym_COLON, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + anon_sym_COLON_COLON, + ACTIONS(537), 21, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_COLON_COLON_COLON, + [16460] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(643), 7, + anon_sym_COLON, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + anon_sym_COLON_COLON, + ACTIONS(641), 21, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_COLON_COLON_COLON, + [16496] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(523), 7, + anon_sym_COLON, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + anon_sym_COLON_COLON, + ACTIONS(521), 21, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_COLON_COLON_COLON, + [16532] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(653), 7, + anon_sym_COLON, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + anon_sym_COLON_COLON, + ACTIONS(651), 21, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_COLON_COLON_COLON, + [16568] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(551), 7, + anon_sym_COLON, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + anon_sym_COLON_COLON, + ACTIONS(549), 21, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + anon_sym_COLON_COLON_COLON, + [16604] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(723), 1, + sym_tailstrict, + ACTIONS(491), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(489), 20, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [16640] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(727), 11, + sym__string_start, + sym_dollar, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_BANG, + anon_sym_TILDE, + sym__number, + anon_sym_AT, + sym__single, + sym__double, + ACTIONS(725), 15, + sym_null, + sym_true, + sym_false, + sym_self, + sym_super, + sym_local, + sym__ident, + anon_sym_if, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_function, + anon_sym_import, + anon_sym_importstr, + anon_sym_error, + anon_sym_assert, + [16674] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(729), 1, + sym_tailstrict, + ACTIONS(503), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(501), 20, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [16710] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(733), 11, + sym__string_start, + sym_dollar, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_BANG, + anon_sym_TILDE, + sym__number, + anon_sym_AT, + sym__single, + sym__double, + ACTIONS(731), 15, + sym_null, + sym_true, + sym_false, + sym_self, + sym_super, + sym_local, + sym__ident, + anon_sym_if, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_function, + anon_sym_import, + anon_sym_importstr, + anon_sym_error, + anon_sym_assert, + [16744] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(739), 1, + anon_sym_EQ, + ACTIONS(737), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(735), 20, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [16780] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(743), 11, + sym__string_start, + sym_dollar, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_BANG, + anon_sym_TILDE, + sym__number, + anon_sym_AT, + sym__single, + sym__double, + ACTIONS(741), 15, + sym_null, + sym_true, + sym_false, + sym_self, + sym_super, + sym_local, + sym__ident, + anon_sym_if, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_function, + anon_sym_import, + anon_sym_importstr, + anon_sym_error, + anon_sym_assert, + [16814] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(749), 1, + sym_super, + ACTIONS(747), 11, + sym__string_start, + sym_dollar, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_BANG, + anon_sym_TILDE, + sym__number, + anon_sym_AT, + sym__single, + sym__double, + ACTIONS(745), 14, + sym_null, + sym_true, + sym_false, + sym_self, + sym_local, + sym__ident, + anon_sym_if, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_function, + anon_sym_import, + anon_sym_importstr, + anon_sym_error, + anon_sym_assert, + [16850] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(751), 1, + sym_super, + ACTIONS(747), 11, + sym__string_start, + sym_dollar, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_BANG, + anon_sym_TILDE, + sym__number, + anon_sym_AT, + sym__single, + sym__double, + ACTIONS(745), 14, + sym_null, + sym_true, + sym_false, + sym_self, + sym_local, + sym__ident, + anon_sym_if, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_function, + anon_sym_import, + anon_sym_importstr, + anon_sym_error, + anon_sym_assert, + [16886] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(747), 11, + sym__string_start, + sym_dollar, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_BANG, + anon_sym_TILDE, + sym__number, + anon_sym_AT, + sym__single, + sym__double, + ACTIONS(745), 15, + sym_null, + sym_true, + sym_false, + sym_self, + sym_super, + sym_local, + sym__ident, + anon_sym_if, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_function, + anon_sym_import, + anon_sym_importstr, + anon_sym_error, + anon_sym_assert, + [16920] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(755), 11, + sym__string_start, + sym_dollar, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_BANG, + anon_sym_TILDE, + sym__number, + anon_sym_AT, + sym__single, + sym__double, + ACTIONS(753), 15, + sym_null, + sym_true, + sym_false, + sym_self, + sym_super, + sym_local, + sym__ident, + anon_sym_if, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_function, + anon_sym_import, + anon_sym_importstr, + anon_sym_error, + anon_sym_assert, + [16954] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(759), 11, + sym__string_start, + sym_dollar, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_BANG, + anon_sym_TILDE, + sym__number, + anon_sym_AT, + sym__single, + sym__double, + ACTIONS(757), 15, + sym_null, + sym_true, + sym_false, + sym_self, + sym_super, + sym_local, + sym__ident, + anon_sym_if, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_function, + anon_sym_import, + anon_sym_importstr, + anon_sym_error, + anon_sym_assert, + [16988] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(597), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(595), 20, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [17021] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(593), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(591), 20, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [17054] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(573), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(571), 20, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [17087] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(635), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(633), 20, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [17120] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(601), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(599), 20, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [17153] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(639), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(637), 20, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [17186] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(535), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(533), 20, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [17219] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(589), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(587), 20, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [17252] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(647), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(645), 20, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [17285] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(491), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(489), 20, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [17318] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(631), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(629), 20, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [17351] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(627), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(625), 20, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [17384] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(581), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(579), 20, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [17417] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(605), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(603), 20, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [17450] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(657), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(655), 20, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [17483] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(515), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(513), 20, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [17516] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(543), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(541), 20, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [17549] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(531), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(529), 20, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [17582] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(565), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(563), 20, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [17615] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(527), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(525), 20, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [17648] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(569), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(567), 20, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [17681] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(577), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(575), 20, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [17714] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(623), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(621), 20, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [17747] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(555), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(553), 20, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [17780] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(615), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(613), 20, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [17813] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(547), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(545), 20, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [17846] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(561), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(559), 20, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [17879] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(519), 5, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + sym_bitand, + sym_bitor, + ACTIONS(517), 20, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_else, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_in, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_bitxor, + sym_and, + sym_or, + [17912] = 19, + ACTIONS(3), 1, + sym_comment, + ACTIONS(5), 1, + sym__ident, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(39), 1, + anon_sym_AT, + ACTIONS(41), 1, + sym__single, + ACTIONS(43), 1, + sym__double, + ACTIONS(45), 1, + sym__string_start, + ACTIONS(761), 1, + sym_local, + ACTIONS(763), 1, + anon_sym_RBRACE, + ACTIONS(765), 1, + anon_sym_LBRACK, + STATE(195), 1, + sym__string, + STATE(246), 1, + aux_sym_objforloop_repeat1, + STATE(267), 1, + sym_fieldname, + STATE(270), 1, + sym_field, + STATE(335), 1, + sym_member, + STATE(337), 1, + sym_assert, + STATE(351), 1, + sym_objlocal, + STATE(384), 1, + sym_objforloop, + STATE(268), 2, + sym_string, + sym_id, + [17971] = 19, + ACTIONS(3), 1, + sym_comment, + ACTIONS(5), 1, + sym__ident, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(39), 1, + anon_sym_AT, + ACTIONS(41), 1, + sym__single, + ACTIONS(43), 1, + sym__double, + ACTIONS(45), 1, + sym__string_start, + ACTIONS(761), 1, + sym_local, + ACTIONS(765), 1, + anon_sym_LBRACK, + ACTIONS(767), 1, + anon_sym_RBRACE, + STATE(195), 1, + sym__string, + STATE(246), 1, + aux_sym_objforloop_repeat1, + STATE(267), 1, + sym_fieldname, + STATE(270), 1, + sym_field, + STATE(334), 1, + sym_member, + STATE(337), 1, + sym_assert, + STATE(351), 1, + sym_objlocal, + STATE(383), 1, + sym_objforloop, + STATE(268), 2, + sym_string, + sym_id, + [18030] = 15, + ACTIONS(3), 1, + sym_comment, + ACTIONS(5), 1, + sym__ident, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(39), 1, + anon_sym_AT, + ACTIONS(41), 1, + sym__single, + ACTIONS(43), 1, + sym__double, + ACTIONS(45), 1, + sym__string_start, + ACTIONS(761), 1, + sym_local, + ACTIONS(765), 1, + anon_sym_LBRACK, + ACTIONS(769), 1, + anon_sym_RBRACE, + STATE(195), 1, + sym__string, + STATE(267), 1, + sym_fieldname, + STATE(345), 1, + sym_member, + STATE(268), 2, + sym_string, + sym_id, + STATE(337), 3, + sym_field, + sym_objlocal, + sym_assert, + [18079] = 15, + ACTIONS(3), 1, + sym_comment, + ACTIONS(5), 1, + sym__ident, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(39), 1, + anon_sym_AT, + ACTIONS(41), 1, + sym__single, + ACTIONS(43), 1, + sym__double, + ACTIONS(45), 1, + sym__string_start, + ACTIONS(761), 1, + sym_local, + ACTIONS(765), 1, + anon_sym_LBRACK, + ACTIONS(771), 1, + anon_sym_RBRACE, + STATE(195), 1, + sym__string, + STATE(267), 1, + sym_fieldname, + STATE(345), 1, + sym_member, + STATE(268), 2, + sym_string, + sym_id, + STATE(337), 3, + sym_field, + sym_objlocal, + sym_assert, + [18128] = 15, + ACTIONS(3), 1, + sym_comment, + ACTIONS(5), 1, + sym__ident, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(39), 1, + anon_sym_AT, + ACTIONS(41), 1, + sym__single, + ACTIONS(43), 1, + sym__double, + ACTIONS(45), 1, + sym__string_start, + ACTIONS(761), 1, + sym_local, + ACTIONS(765), 1, + anon_sym_LBRACK, + ACTIONS(773), 1, + anon_sym_RBRACE, + STATE(195), 1, + sym__string, + STATE(267), 1, + sym_fieldname, + STATE(345), 1, + sym_member, + STATE(268), 2, + sym_string, + sym_id, + STATE(337), 3, + sym_field, + sym_objlocal, + sym_assert, + [18177] = 15, + ACTIONS(3), 1, + sym_comment, + ACTIONS(5), 1, + sym__ident, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(39), 1, + anon_sym_AT, + ACTIONS(41), 1, + sym__single, + ACTIONS(43), 1, + sym__double, + ACTIONS(45), 1, + sym__string_start, + ACTIONS(761), 1, + sym_local, + ACTIONS(765), 1, + anon_sym_LBRACK, + ACTIONS(775), 1, + anon_sym_RBRACE, + STATE(195), 1, + sym__string, + STATE(267), 1, + sym_fieldname, + STATE(345), 1, + sym_member, + STATE(268), 2, + sym_string, + sym_id, + STATE(337), 3, + sym_field, + sym_objlocal, + sym_assert, + [18226] = 14, + ACTIONS(3), 1, + sym_comment, + ACTIONS(5), 1, + sym__ident, + ACTIONS(35), 1, + anon_sym_assert, + ACTIONS(39), 1, + anon_sym_AT, + ACTIONS(41), 1, + sym__single, + ACTIONS(43), 1, + sym__double, + ACTIONS(45), 1, + sym__string_start, + ACTIONS(761), 1, + sym_local, + ACTIONS(765), 1, + anon_sym_LBRACK, + STATE(195), 1, + sym__string, + STATE(267), 1, + sym_fieldname, + STATE(345), 1, + sym_member, + STATE(268), 2, + sym_string, + sym_id, + STATE(337), 3, + sym_field, + sym_objlocal, + sym_assert, + [18272] = 14, + ACTIONS(3), 1, + sym_comment, + ACTIONS(5), 1, + sym__ident, + ACTIONS(39), 1, + anon_sym_AT, + ACTIONS(41), 1, + sym__single, + ACTIONS(43), 1, + sym__double, + ACTIONS(45), 1, + sym__string_start, + ACTIONS(761), 1, + sym_local, + ACTIONS(765), 1, + anon_sym_LBRACK, + STATE(195), 1, + sym__string, + STATE(247), 1, + aux_sym_objforloop_repeat1, + STATE(267), 1, + sym_fieldname, + STATE(289), 1, + sym_field, + STATE(353), 1, + sym_objlocal, + STATE(268), 2, + sym_string, + sym_id, + [18316] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(777), 1, + sym__ident, + ACTIONS(779), 1, + sym_local, + STATE(247), 1, + aux_sym_objforloop_repeat1, + STATE(353), 1, + sym_objlocal, + ACTIONS(782), 5, + sym__string_start, + anon_sym_LBRACK, + anon_sym_AT, + sym__single, + sym__double, + [18339] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(497), 1, + anon_sym_for, + ACTIONS(784), 1, + anon_sym_RBRACE, + ACTIONS(786), 1, + anon_sym_if, + STATE(373), 1, + sym_compspec, + STATE(249), 3, + sym_forspec, + sym_ifspec, + aux_sym_compspec_repeat1, + [18360] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(497), 1, + anon_sym_for, + ACTIONS(786), 1, + anon_sym_if, + ACTIONS(788), 2, + anon_sym_RBRACE, + anon_sym_RBRACK, + STATE(252), 3, + sym_forspec, + sym_ifspec, + aux_sym_compspec_repeat1, + [18379] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(497), 1, + anon_sym_for, + ACTIONS(786), 1, + anon_sym_if, + ACTIONS(790), 1, + anon_sym_RBRACE, + STATE(381), 1, + sym_compspec, + STATE(249), 3, + sym_forspec, + sym_ifspec, + aux_sym_compspec_repeat1, + [18400] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(497), 1, + anon_sym_for, + ACTIONS(786), 1, + anon_sym_if, + ACTIONS(792), 1, + anon_sym_RBRACE, + STATE(360), 1, + sym_compspec, + STATE(249), 3, + sym_forspec, + sym_ifspec, + aux_sym_compspec_repeat1, + [18421] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(796), 1, + anon_sym_if, + ACTIONS(799), 1, + anon_sym_for, + ACTIONS(794), 2, + anon_sym_RBRACE, + anon_sym_RBRACK, + STATE(252), 3, + sym_forspec, + sym_ifspec, + aux_sym_compspec_repeat1, + [18440] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(777), 2, + sym_local, + sym__ident, + ACTIONS(782), 5, + sym__string_start, + anon_sym_LBRACK, + anon_sym_AT, + sym__single, + sym__double, + [18455] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(497), 1, + anon_sym_for, + ACTIONS(786), 1, + anon_sym_if, + ACTIONS(802), 1, + anon_sym_RBRACK, + STATE(365), 1, + sym_compspec, + STATE(249), 3, + sym_forspec, + sym_ifspec, + aux_sym_compspec_repeat1, + [18476] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(497), 1, + anon_sym_for, + ACTIONS(786), 1, + anon_sym_if, + ACTIONS(804), 1, + anon_sym_RBRACK, + STATE(380), 1, + sym_compspec, + STATE(249), 3, + sym_forspec, + sym_ifspec, + aux_sym_compspec_repeat1, + [18497] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(497), 1, + anon_sym_for, + ACTIONS(786), 1, + anon_sym_if, + ACTIONS(806), 1, + anon_sym_RBRACE, + STATE(356), 1, + sym_compspec, + STATE(249), 3, + sym_forspec, + sym_ifspec, + aux_sym_compspec_repeat1, + [18518] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(497), 1, + anon_sym_for, + ACTIONS(786), 1, + anon_sym_if, + ACTIONS(808), 1, + anon_sym_RBRACK, + STATE(371), 1, + sym_compspec, + STATE(249), 3, + sym_forspec, + sym_ifspec, + aux_sym_compspec_repeat1, + [18539] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(497), 1, + anon_sym_for, + ACTIONS(786), 1, + anon_sym_if, + ACTIONS(810), 1, + anon_sym_RBRACK, + STATE(366), 1, + sym_compspec, + STATE(249), 3, + sym_forspec, + sym_ifspec, + aux_sym_compspec_repeat1, + [18560] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + STATE(113), 1, + sym__string, + STATE(139), 1, + sym_string, + [18582] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(39), 1, + anon_sym_AT, + ACTIONS(41), 1, + sym__single, + ACTIONS(43), 1, + sym__double, + ACTIONS(45), 1, + sym__string_start, + STATE(195), 1, + sym__string, + STATE(214), 1, + sym_string, + [18604] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(39), 1, + anon_sym_AT, + ACTIONS(41), 1, + sym__single, + ACTIONS(43), 1, + sym__double, + ACTIONS(45), 1, + sym__string_start, + STATE(195), 1, + sym__string, + STATE(216), 1, + sym_string, + [18626] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(79), 1, + anon_sym_AT, + ACTIONS(81), 1, + sym__single, + ACTIONS(83), 1, + sym__double, + ACTIONS(85), 1, + sym__string_start, + STATE(113), 1, + sym__string, + STATE(140), 1, + sym_string, + [18648] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(812), 1, + sym__ident, + ACTIONS(814), 1, + anon_sym_RPAREN, + STATE(322), 1, + sym_id, + STATE(325), 1, + sym_param, + STATE(357), 1, + sym_params, + [18667] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(812), 1, + sym__ident, + ACTIONS(816), 1, + anon_sym_RPAREN, + STATE(322), 1, + sym_id, + STATE(325), 1, + sym_param, + STATE(375), 1, + sym_params, + [18686] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(812), 1, + sym__ident, + ACTIONS(818), 1, + anon_sym_RPAREN, + STATE(322), 1, + sym_id, + STATE(325), 1, + sym_param, + STATE(355), 1, + sym_params, + [18705] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(812), 1, + sym__ident, + ACTIONS(820), 1, + anon_sym_RPAREN, + STATE(322), 1, + sym_id, + STATE(325), 1, + sym_param, + STATE(359), 1, + sym_params, + [18724] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(824), 1, + anon_sym_LPAREN, + ACTIONS(826), 1, + anon_sym_PLUS, + ACTIONS(828), 1, + anon_sym_COLON_COLON_COLON, + ACTIONS(822), 2, + anon_sym_COLON, + anon_sym_COLON_COLON, + [18741] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(830), 2, + anon_sym_COLON, + anon_sym_COLON_COLON, + ACTIONS(832), 3, + anon_sym_LPAREN, + anon_sym_PLUS, + anon_sym_COLON_COLON_COLON, + [18754] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(834), 2, + anon_sym_COLON, + anon_sym_COLON_COLON, + ACTIONS(836), 3, + anon_sym_LPAREN, + anon_sym_PLUS, + anon_sym_COLON_COLON_COLON, + [18767] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(497), 1, + anon_sym_for, + STATE(248), 1, + sym_forspec, + STATE(293), 1, + aux_sym_objforloop_repeat2, + ACTIONS(838), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [18784] = 4, + ACTIONS(840), 1, + sym_comment, + ACTIONS(842), 1, + sym__double, + STATE(278), 1, + aux_sym__str_double, + ACTIONS(844), 2, + aux_sym__str_double_token1, + sym_escape_sequence, + [18798] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(846), 1, + anon_sym_COMMA, + STATE(272), 1, + aux_sym_array_repeat1, + ACTIONS(663), 2, + anon_sym_RBRACK, + anon_sym_RPAREN, + [18812] = 4, + ACTIONS(840), 1, + sym_comment, + ACTIONS(849), 1, + sym__double, + STATE(298), 1, + aux_sym__str_double, + ACTIONS(844), 2, + aux_sym__str_double_token1, + sym_escape_sequence, + [18826] = 4, + ACTIONS(840), 1, + sym_comment, + ACTIONS(849), 1, + sym__single, + STATE(295), 1, + aux_sym__str_single, + ACTIONS(851), 2, + aux_sym__str_single_token1, + sym_escape_sequence, + [18840] = 4, + ACTIONS(840), 1, + sym_comment, + ACTIONS(853), 1, + sym__double, + STATE(285), 1, + aux_sym__str_double, + ACTIONS(844), 2, + aux_sym__str_double_token1, + sym_escape_sequence, + [18854] = 4, + ACTIONS(840), 1, + sym_comment, + ACTIONS(853), 1, + sym__single, + STATE(286), 1, + aux_sym__str_single, + ACTIONS(851), 2, + aux_sym__str_single_token1, + sym_escape_sequence, + [18868] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(147), 1, + anon_sym_RPAREN, + ACTIONS(855), 1, + anon_sym_COMMA, + STATE(272), 1, + aux_sym_array_repeat1, + STATE(318), 1, + aux_sym_args_repeat1, + [18884] = 4, + ACTIONS(840), 1, + sym_comment, + ACTIONS(857), 1, + sym__double, + STATE(278), 1, + aux_sym__str_double, + ACTIONS(859), 2, + aux_sym__str_double_token1, + sym_escape_sequence, + [18898] = 4, + ACTIONS(840), 1, + sym_comment, + ACTIONS(862), 1, + sym__single, + STATE(279), 1, + aux_sym__str_single, + ACTIONS(864), 2, + aux_sym__str_single_token1, + sym_escape_sequence, + [18912] = 4, + ACTIONS(840), 1, + sym_comment, + ACTIONS(867), 1, + sym__double, + STATE(296), 1, + aux_sym__str_double, + ACTIONS(844), 2, + aux_sym__str_double_token1, + sym_escape_sequence, + [18926] = 4, + ACTIONS(840), 1, + sym_comment, + ACTIONS(842), 1, + sym__single, + STATE(279), 1, + aux_sym__str_single, + ACTIONS(851), 2, + aux_sym__str_single_token1, + sym_escape_sequence, + [18940] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(129), 1, + anon_sym_RPAREN, + ACTIONS(812), 1, + sym__ident, + STATE(344), 1, + sym_named_argument, + STATE(364), 1, + sym_id, + [18956] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(497), 1, + anon_sym_for, + ACTIONS(869), 1, + anon_sym_COMMA, + STATE(251), 1, + sym_forspec, + STATE(328), 1, + aux_sym_objforloop_repeat2, + [18972] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(497), 1, + anon_sym_for, + ACTIONS(871), 1, + sym_local, + STATE(256), 1, + sym_forspec, + STATE(339), 1, + sym_objlocal, + [18988] = 4, + ACTIONS(840), 1, + sym_comment, + ACTIONS(873), 1, + sym__double, + STATE(278), 1, + aux_sym__str_double, + ACTIONS(844), 2, + aux_sym__str_double_token1, + sym_escape_sequence, + [19002] = 4, + ACTIONS(840), 1, + sym_comment, + ACTIONS(873), 1, + sym__single, + STATE(279), 1, + aux_sym__str_single, + ACTIONS(851), 2, + aux_sym__str_single_token1, + sym_escape_sequence, + [19016] = 4, + ACTIONS(840), 1, + sym_comment, + ACTIONS(867), 1, + sym__single, + STATE(300), 1, + aux_sym__str_single, + ACTIONS(851), 2, + aux_sym__str_single_token1, + sym_escape_sequence, + [19030] = 4, + ACTIONS(840), 1, + sym_comment, + ACTIONS(875), 1, + sym__single, + STATE(281), 1, + aux_sym__str_single, + ACTIONS(851), 2, + aux_sym__str_single_token1, + sym_escape_sequence, + [19044] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(497), 1, + anon_sym_for, + ACTIONS(877), 1, + anon_sym_COMMA, + STATE(250), 1, + sym_forspec, + STATE(283), 1, + aux_sym_objforloop_repeat2, + [19060] = 4, + ACTIONS(840), 1, + sym_comment, + ACTIONS(875), 1, + sym__double, + STATE(271), 1, + aux_sym__str_double, + ACTIONS(844), 2, + aux_sym__str_double_token1, + sym_escape_sequence, + [19074] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(497), 1, + anon_sym_for, + ACTIONS(871), 1, + sym_local, + STATE(251), 1, + sym_forspec, + STATE(339), 1, + sym_objlocal, + [19090] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(812), 1, + sym__ident, + ACTIONS(879), 1, + anon_sym_RPAREN, + STATE(322), 1, + sym_id, + STATE(340), 1, + sym_param, + [19106] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(497), 1, + anon_sym_for, + ACTIONS(877), 1, + anon_sym_COMMA, + STATE(250), 1, + sym_forspec, + STATE(328), 1, + aux_sym_objforloop_repeat2, + [19122] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(812), 1, + sym__ident, + ACTIONS(881), 1, + anon_sym_RPAREN, + STATE(344), 1, + sym_named_argument, + STATE(364), 1, + sym_id, + [19138] = 4, + ACTIONS(840), 1, + sym_comment, + ACTIONS(883), 1, + sym__single, + STATE(279), 1, + aux_sym__str_single, + ACTIONS(851), 2, + aux_sym__str_single_token1, + sym_escape_sequence, + [19152] = 4, + ACTIONS(840), 1, + sym_comment, + ACTIONS(885), 1, + sym__double, + STATE(278), 1, + aux_sym__str_double, + ACTIONS(844), 2, + aux_sym__str_double_token1, + sym_escape_sequence, + [19166] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(812), 1, + sym__ident, + ACTIONS(887), 1, + anon_sym_RPAREN, + STATE(322), 1, + sym_id, + STATE(340), 1, + sym_param, + [19182] = 4, + ACTIONS(840), 1, + sym_comment, + ACTIONS(883), 1, + sym__double, + STATE(278), 1, + aux_sym__str_double, + ACTIONS(844), 2, + aux_sym__str_double_token1, + sym_escape_sequence, + [19196] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(147), 1, + anon_sym_RPAREN, + ACTIONS(812), 1, + sym__ident, + STATE(344), 1, + sym_named_argument, + STATE(364), 1, + sym_id, + [19212] = 4, + ACTIONS(840), 1, + sym_comment, + ACTIONS(885), 1, + sym__single, + STATE(279), 1, + aux_sym__str_single, + ACTIONS(851), 2, + aux_sym__str_single_token1, + sym_escape_sequence, + [19226] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(889), 1, + anon_sym_COMMA, + ACTIONS(891), 1, + anon_sym_SEMI, + STATE(307), 1, + aux_sym_local_bind_repeat1, + [19239] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(889), 1, + anon_sym_COMMA, + ACTIONS(893), 1, + anon_sym_SEMI, + STATE(327), 1, + aux_sym_local_bind_repeat1, + [19252] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(895), 1, + sym__single, + ACTIONS(897), 1, + sym__double, + ACTIONS(899), 1, + sym__string_start, + [19265] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(773), 1, + anon_sym_RBRACE, + ACTIONS(901), 1, + anon_sym_COMMA, + STATE(333), 1, + aux_sym_objinside_repeat1, + [19278] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(812), 1, + sym__ident, + STATE(301), 1, + sym_bind, + STATE(349), 1, + sym_id, + [19291] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(903), 3, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_for, + [19300] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(889), 1, + anon_sym_COMMA, + ACTIONS(905), 1, + anon_sym_SEMI, + STATE(332), 1, + aux_sym_local_bind_repeat1, + [19313] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(812), 1, + sym__ident, + STATE(342), 1, + sym_bind, + STATE(349), 1, + sym_id, + [19326] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(812), 1, + sym__ident, + STATE(302), 1, + sym_bind, + STATE(349), 1, + sym_id, + [19339] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(907), 1, + anon_sym_COMMA, + ACTIONS(910), 1, + anon_sym_RPAREN, + STATE(310), 1, + aux_sym_params_repeat1, + [19352] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(147), 1, + anon_sym_RPAREN, + ACTIONS(912), 1, + anon_sym_COMMA, + STATE(319), 1, + aux_sym_args_repeat1, + [19365] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(887), 1, + anon_sym_RPAREN, + ACTIONS(914), 1, + anon_sym_COMMA, + STATE(310), 1, + aux_sym_params_repeat1, + [19378] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(916), 1, + sym__single, + ACTIONS(918), 1, + sym__double, + ACTIONS(920), 1, + sym__string_start, + [19391] = 3, + ACTIONS(840), 1, + sym_comment, + ACTIONS(922), 1, + sym__double, + ACTIONS(924), 2, + aux_sym__str_double_token1, + sym_escape_sequence, + [19402] = 3, + ACTIONS(840), 1, + sym_comment, + ACTIONS(926), 1, + sym__single, + ACTIONS(928), 2, + aux_sym__str_single_token1, + sym_escape_sequence, + [19413] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(932), 1, + anon_sym_COLON_COLON_COLON, + ACTIONS(930), 2, + anon_sym_COLON, + anon_sym_COLON_COLON, + [19424] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(936), 1, + anon_sym_COLON_COLON_COLON, + ACTIONS(934), 2, + anon_sym_COLON, + anon_sym_COLON_COLON, + [19435] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(129), 1, + anon_sym_RPAREN, + ACTIONS(938), 1, + anon_sym_COMMA, + STATE(319), 1, + aux_sym_args_repeat1, + [19448] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(940), 1, + anon_sym_COMMA, + ACTIONS(943), 1, + anon_sym_RPAREN, + STATE(319), 1, + aux_sym_args_repeat1, + [19461] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(812), 1, + sym__ident, + STATE(322), 1, + sym_id, + STATE(340), 1, + sym_param, + [19474] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(87), 1, + anon_sym_RBRACK, + ACTIONS(945), 1, + anon_sym_COMMA, + STATE(272), 1, + aux_sym_array_repeat1, + [19487] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(949), 1, + anon_sym_EQ, + ACTIONS(947), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + [19498] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(61), 1, + anon_sym_RBRACK, + ACTIONS(951), 1, + anon_sym_COMMA, + STATE(272), 1, + aux_sym_array_repeat1, + [19511] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(812), 1, + sym__ident, + STATE(344), 1, + sym_named_argument, + STATE(364), 1, + sym_id, + [19524] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(953), 1, + anon_sym_COMMA, + ACTIONS(955), 1, + anon_sym_RPAREN, + STATE(312), 1, + aux_sym_params_repeat1, + [19537] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(775), 1, + anon_sym_RBRACE, + ACTIONS(957), 1, + anon_sym_COMMA, + STATE(333), 1, + aux_sym_objinside_repeat1, + [19550] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(889), 1, + anon_sym_COMMA, + ACTIONS(959), 1, + anon_sym_SEMI, + STATE(332), 1, + aux_sym_local_bind_repeat1, + [19563] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(961), 1, + anon_sym_COMMA, + ACTIONS(964), 1, + anon_sym_for, + STATE(328), 1, + aux_sym_objforloop_repeat2, + [19576] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(812), 1, + sym__ident, + STATE(306), 1, + sym_bind, + STATE(349), 1, + sym_id, + [19589] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(968), 1, + anon_sym_COLON_COLON_COLON, + ACTIONS(966), 2, + anon_sym_COLON, + anon_sym_COLON_COLON, + [19600] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(585), 1, + anon_sym_RPAREN, + ACTIONS(970), 1, + anon_sym_COMMA, + STATE(311), 1, + aux_sym_args_repeat1, + [19613] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(972), 1, + anon_sym_COMMA, + ACTIONS(975), 1, + anon_sym_SEMI, + STATE(332), 1, + aux_sym_local_bind_repeat1, + [19626] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(977), 1, + anon_sym_RBRACE, + ACTIONS(979), 1, + anon_sym_COMMA, + STATE(333), 1, + aux_sym_objinside_repeat1, + [19639] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(982), 1, + anon_sym_RBRACE, + ACTIONS(984), 1, + anon_sym_COMMA, + STATE(304), 1, + aux_sym_objinside_repeat1, + [19652] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(986), 1, + anon_sym_RBRACE, + ACTIONS(988), 1, + anon_sym_COMMA, + STATE(326), 1, + aux_sym_objinside_repeat1, + [19665] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(990), 1, + sym__ident, + STATE(117), 1, + sym_id, + [19675] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(838), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [19683] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(992), 1, + anon_sym_LBRACK, + ACTIONS(994), 1, + anon_sym_DOT, + [19693] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(964), 2, + anon_sym_COMMA, + anon_sym_for, + [19701] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(910), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + [19709] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(812), 1, + sym__ident, + STATE(234), 1, + sym_id, + [19719] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(975), 2, + anon_sym_COMMA, + anon_sym_SEMI, + [19727] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(812), 1, + sym__ident, + STATE(377), 1, + sym_id, + [19737] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(943), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + [19745] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(977), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [19753] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(990), 1, + sym__ident, + STATE(114), 1, + sym_id, + [19763] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(812), 1, + sym__ident, + STATE(227), 1, + sym_id, + [19773] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(996), 1, + anon_sym_LBRACK, + ACTIONS(998), 1, + anon_sym_DOT, + [19783] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1000), 1, + anon_sym_LPAREN, + ACTIONS(1002), 1, + anon_sym_EQ, + [19793] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(871), 1, + sym_local, + STATE(339), 1, + sym_objlocal, + [19803] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(838), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [19811] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1004), 1, + sym__string_end, + [19818] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1006), 1, + anon_sym_COMMA, + [19825] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1008), 1, + anon_sym_SEMI, + [19832] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1010), 1, + anon_sym_RPAREN, + [19839] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1012), 1, + anon_sym_RBRACE, + [19846] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1014), 1, + anon_sym_RPAREN, + [19853] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1016), 1, + sym__string_end, + [19860] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1018), 1, + anon_sym_RPAREN, + [19867] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(806), 1, + anon_sym_RBRACE, + [19874] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1020), 1, + sym__string_end, + [19881] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1022), 1, + sym__string_end, + [19888] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1024), 1, + anon_sym_RPAREN, + [19895] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1026), 1, + anon_sym_EQ, + [19902] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(804), 1, + anon_sym_RBRACK, + [19909] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(808), 1, + anon_sym_RBRACK, + [19916] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1028), 1, + anon_sym_SEMI, + [19923] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1030), 1, + ts_builtin_sym_end, + [19930] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1032), 1, + anon_sym_RPAREN, + [19937] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1034), 1, + sym__string_content, + [19944] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1036), 1, + anon_sym_RBRACK, + [19951] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1038), 1, + sym__string_content, + [19958] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(790), 1, + anon_sym_RBRACE, + [19965] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1040), 1, + anon_sym_EQ, + [19972] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1042), 1, + anon_sym_RPAREN, + [19979] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1044), 1, + anon_sym_LPAREN, + [19986] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1046), 1, + anon_sym_in, + [19993] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1048), 1, + sym__string_content, + [20000] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1050), 1, + anon_sym_EQ, + [20007] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1052), 1, + anon_sym_RBRACK, + [20014] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(792), 1, + anon_sym_RBRACE, + [20021] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1054), 1, + anon_sym_LPAREN, + [20028] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(982), 1, + anon_sym_RBRACE, + [20035] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(986), 1, + anon_sym_RBRACE, + [20042] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1056), 1, + sym__string_content, +}; + +static const uint32_t ts_small_parse_table_map[] = { + [SMALL_STATE(2)] = 0, + [SMALL_STATE(3)] = 116, + [SMALL_STATE(4)] = 232, + [SMALL_STATE(5)] = 350, + [SMALL_STATE(6)] = 468, + [SMALL_STATE(7)] = 581, + [SMALL_STATE(8)] = 694, + [SMALL_STATE(9)] = 807, + [SMALL_STATE(10)] = 920, + [SMALL_STATE(11)] = 1035, + [SMALL_STATE(12)] = 1148, + [SMALL_STATE(13)] = 1261, + [SMALL_STATE(14)] = 1376, + [SMALL_STATE(15)] = 1486, + [SMALL_STATE(16)] = 1596, + [SMALL_STATE(17)] = 1706, + [SMALL_STATE(18)] = 1816, + [SMALL_STATE(19)] = 1926, + [SMALL_STATE(20)] = 2036, + [SMALL_STATE(21)] = 2146, + [SMALL_STATE(22)] = 2256, + [SMALL_STATE(23)] = 2366, + [SMALL_STATE(24)] = 2476, + [SMALL_STATE(25)] = 2583, + [SMALL_STATE(26)] = 2690, + [SMALL_STATE(27)] = 2797, + [SMALL_STATE(28)] = 2904, + [SMALL_STATE(29)] = 3011, + [SMALL_STATE(30)] = 3118, + [SMALL_STATE(31)] = 3225, + [SMALL_STATE(32)] = 3332, + [SMALL_STATE(33)] = 3439, + [SMALL_STATE(34)] = 3546, + [SMALL_STATE(35)] = 3653, + [SMALL_STATE(36)] = 3760, + [SMALL_STATE(37)] = 3867, + [SMALL_STATE(38)] = 3974, + [SMALL_STATE(39)] = 4081, + [SMALL_STATE(40)] = 4188, + [SMALL_STATE(41)] = 4295, + [SMALL_STATE(42)] = 4402, + [SMALL_STATE(43)] = 4509, + [SMALL_STATE(44)] = 4616, + [SMALL_STATE(45)] = 4723, + [SMALL_STATE(46)] = 4830, + [SMALL_STATE(47)] = 4937, + [SMALL_STATE(48)] = 5044, + [SMALL_STATE(49)] = 5151, + [SMALL_STATE(50)] = 5258, + [SMALL_STATE(51)] = 5365, + [SMALL_STATE(52)] = 5472, + [SMALL_STATE(53)] = 5579, + [SMALL_STATE(54)] = 5686, + [SMALL_STATE(55)] = 5793, + [SMALL_STATE(56)] = 5900, + [SMALL_STATE(57)] = 6007, + [SMALL_STATE(58)] = 6114, + [SMALL_STATE(59)] = 6221, + [SMALL_STATE(60)] = 6328, + [SMALL_STATE(61)] = 6435, + [SMALL_STATE(62)] = 6542, + [SMALL_STATE(63)] = 6649, + [SMALL_STATE(64)] = 6756, + [SMALL_STATE(65)] = 6863, + [SMALL_STATE(66)] = 6970, + [SMALL_STATE(67)] = 7077, + [SMALL_STATE(68)] = 7184, + [SMALL_STATE(69)] = 7291, + [SMALL_STATE(70)] = 7398, + [SMALL_STATE(71)] = 7505, + [SMALL_STATE(72)] = 7612, + [SMALL_STATE(73)] = 7719, + [SMALL_STATE(74)] = 7826, + [SMALL_STATE(75)] = 7933, + [SMALL_STATE(76)] = 8040, + [SMALL_STATE(77)] = 8147, + [SMALL_STATE(78)] = 8254, + [SMALL_STATE(79)] = 8361, + [SMALL_STATE(80)] = 8468, + [SMALL_STATE(81)] = 8575, + [SMALL_STATE(82)] = 8682, + [SMALL_STATE(83)] = 8789, + [SMALL_STATE(84)] = 8874, + [SMALL_STATE(85)] = 8939, + [SMALL_STATE(86)] = 9030, + [SMALL_STATE(87)] = 9121, + [SMALL_STATE(88)] = 9200, + [SMALL_STATE(89)] = 9273, + [SMALL_STATE(90)] = 9338, + [SMALL_STATE(91)] = 9409, + [SMALL_STATE(92)] = 9478, + [SMALL_STATE(93)] = 9563, + [SMALL_STATE(94)] = 9654, + [SMALL_STATE(95)] = 9747, + [SMALL_STATE(96)] = 9834, + [SMALL_STATE(97)] = 9917, + [SMALL_STATE(98)] = 10008, + [SMALL_STATE(99)] = 10089, + [SMALL_STATE(100)] = 10180, + [SMALL_STATE(101)] = 10271, + [SMALL_STATE(102)] = 10362, + [SMALL_STATE(103)] = 10406, + [SMALL_STATE(104)] = 10500, + [SMALL_STATE(105)] = 10544, + [SMALL_STATE(106)] = 10638, + [SMALL_STATE(107)] = 10680, + [SMALL_STATE(108)] = 10721, + [SMALL_STATE(109)] = 10762, + [SMALL_STATE(110)] = 10803, + [SMALL_STATE(111)] = 10844, + [SMALL_STATE(112)] = 10885, + [SMALL_STATE(113)] = 10926, + [SMALL_STATE(114)] = 10967, + [SMALL_STATE(115)] = 11008, + [SMALL_STATE(116)] = 11049, + [SMALL_STATE(117)] = 11090, + [SMALL_STATE(118)] = 11131, + [SMALL_STATE(119)] = 11216, + [SMALL_STATE(120)] = 11257, + [SMALL_STATE(121)] = 11298, + [SMALL_STATE(122)] = 11339, + [SMALL_STATE(123)] = 11380, + [SMALL_STATE(124)] = 11421, + [SMALL_STATE(125)] = 11462, + [SMALL_STATE(126)] = 11553, + [SMALL_STATE(127)] = 11594, + [SMALL_STATE(128)] = 11635, + [SMALL_STATE(129)] = 11676, + [SMALL_STATE(130)] = 11717, + [SMALL_STATE(131)] = 11758, + [SMALL_STATE(132)] = 11843, + [SMALL_STATE(133)] = 11930, + [SMALL_STATE(134)] = 11971, + [SMALL_STATE(135)] = 12056, + [SMALL_STATE(136)] = 12141, + [SMALL_STATE(137)] = 12182, + [SMALL_STATE(138)] = 12223, + [SMALL_STATE(139)] = 12264, + [SMALL_STATE(140)] = 12305, + [SMALL_STATE(141)] = 12346, + [SMALL_STATE(142)] = 12387, + [SMALL_STATE(143)] = 12428, + [SMALL_STATE(144)] = 12469, + [SMALL_STATE(145)] = 12554, + [SMALL_STATE(146)] = 12595, + [SMALL_STATE(147)] = 12636, + [SMALL_STATE(148)] = 12720, + [SMALL_STATE(149)] = 12804, + [SMALL_STATE(150)] = 12888, + [SMALL_STATE(151)] = 12972, + [SMALL_STATE(152)] = 13056, + [SMALL_STATE(153)] = 13140, + [SMALL_STATE(154)] = 13225, + [SMALL_STATE(155)] = 13308, + [SMALL_STATE(156)] = 13373, + [SMALL_STATE(157)] = 13436, + [SMALL_STATE(158)] = 13497, + [SMALL_STATE(159)] = 13554, + [SMALL_STATE(160)] = 13633, + [SMALL_STATE(161)] = 13710, + [SMALL_STATE(162)] = 13787, + [SMALL_STATE(163)] = 13870, + [SMALL_STATE(164)] = 13945, + [SMALL_STATE(165)] = 14018, + [SMALL_STATE(166)] = 14057, + [SMALL_STATE(167)] = 14142, + [SMALL_STATE(168)] = 14199, + [SMALL_STATE(169)] = 14282, + [SMALL_STATE(170)] = 14365, + [SMALL_STATE(171)] = 14448, + [SMALL_STATE(172)] = 14533, + [SMALL_STATE(173)] = 14618, + [SMALL_STATE(174)] = 14701, + [SMALL_STATE(175)] = 14786, + [SMALL_STATE(176)] = 14869, + [SMALL_STATE(177)] = 14940, + [SMALL_STATE(178)] = 15025, + [SMALL_STATE(179)] = 15108, + [SMALL_STATE(180)] = 15193, + [SMALL_STATE(181)] = 15276, + [SMALL_STATE(182)] = 15358, + [SMALL_STATE(183)] = 15440, + [SMALL_STATE(184)] = 15522, + [SMALL_STATE(185)] = 15604, + [SMALL_STATE(186)] = 15686, + [SMALL_STATE(187)] = 15768, + [SMALL_STATE(188)] = 15850, + [SMALL_STATE(189)] = 15932, + [SMALL_STATE(190)] = 16014, + [SMALL_STATE(191)] = 16096, + [SMALL_STATE(192)] = 16178, + [SMALL_STATE(193)] = 16260, + [SMALL_STATE(194)] = 16342, + [SMALL_STATE(195)] = 16424, + [SMALL_STATE(196)] = 16460, + [SMALL_STATE(197)] = 16496, + [SMALL_STATE(198)] = 16532, + [SMALL_STATE(199)] = 16568, + [SMALL_STATE(200)] = 16604, + [SMALL_STATE(201)] = 16640, + [SMALL_STATE(202)] = 16674, + [SMALL_STATE(203)] = 16710, + [SMALL_STATE(204)] = 16744, + [SMALL_STATE(205)] = 16780, + [SMALL_STATE(206)] = 16814, + [SMALL_STATE(207)] = 16850, + [SMALL_STATE(208)] = 16886, + [SMALL_STATE(209)] = 16920, + [SMALL_STATE(210)] = 16954, + [SMALL_STATE(211)] = 16988, + [SMALL_STATE(212)] = 17021, + [SMALL_STATE(213)] = 17054, + [SMALL_STATE(214)] = 17087, + [SMALL_STATE(215)] = 17120, + [SMALL_STATE(216)] = 17153, + [SMALL_STATE(217)] = 17186, + [SMALL_STATE(218)] = 17219, + [SMALL_STATE(219)] = 17252, + [SMALL_STATE(220)] = 17285, + [SMALL_STATE(221)] = 17318, + [SMALL_STATE(222)] = 17351, + [SMALL_STATE(223)] = 17384, + [SMALL_STATE(224)] = 17417, + [SMALL_STATE(225)] = 17450, + [SMALL_STATE(226)] = 17483, + [SMALL_STATE(227)] = 17516, + [SMALL_STATE(228)] = 17549, + [SMALL_STATE(229)] = 17582, + [SMALL_STATE(230)] = 17615, + [SMALL_STATE(231)] = 17648, + [SMALL_STATE(232)] = 17681, + [SMALL_STATE(233)] = 17714, + [SMALL_STATE(234)] = 17747, + [SMALL_STATE(235)] = 17780, + [SMALL_STATE(236)] = 17813, + [SMALL_STATE(237)] = 17846, + [SMALL_STATE(238)] = 17879, + [SMALL_STATE(239)] = 17912, + [SMALL_STATE(240)] = 17971, + [SMALL_STATE(241)] = 18030, + [SMALL_STATE(242)] = 18079, + [SMALL_STATE(243)] = 18128, + [SMALL_STATE(244)] = 18177, + [SMALL_STATE(245)] = 18226, + [SMALL_STATE(246)] = 18272, + [SMALL_STATE(247)] = 18316, + [SMALL_STATE(248)] = 18339, + [SMALL_STATE(249)] = 18360, + [SMALL_STATE(250)] = 18379, + [SMALL_STATE(251)] = 18400, + [SMALL_STATE(252)] = 18421, + [SMALL_STATE(253)] = 18440, + [SMALL_STATE(254)] = 18455, + [SMALL_STATE(255)] = 18476, + [SMALL_STATE(256)] = 18497, + [SMALL_STATE(257)] = 18518, + [SMALL_STATE(258)] = 18539, + [SMALL_STATE(259)] = 18560, + [SMALL_STATE(260)] = 18582, + [SMALL_STATE(261)] = 18604, + [SMALL_STATE(262)] = 18626, + [SMALL_STATE(263)] = 18648, + [SMALL_STATE(264)] = 18667, + [SMALL_STATE(265)] = 18686, + [SMALL_STATE(266)] = 18705, + [SMALL_STATE(267)] = 18724, + [SMALL_STATE(268)] = 18741, + [SMALL_STATE(269)] = 18754, + [SMALL_STATE(270)] = 18767, + [SMALL_STATE(271)] = 18784, + [SMALL_STATE(272)] = 18798, + [SMALL_STATE(273)] = 18812, + [SMALL_STATE(274)] = 18826, + [SMALL_STATE(275)] = 18840, + [SMALL_STATE(276)] = 18854, + [SMALL_STATE(277)] = 18868, + [SMALL_STATE(278)] = 18884, + [SMALL_STATE(279)] = 18898, + [SMALL_STATE(280)] = 18912, + [SMALL_STATE(281)] = 18926, + [SMALL_STATE(282)] = 18940, + [SMALL_STATE(283)] = 18956, + [SMALL_STATE(284)] = 18972, + [SMALL_STATE(285)] = 18988, + [SMALL_STATE(286)] = 19002, + [SMALL_STATE(287)] = 19016, + [SMALL_STATE(288)] = 19030, + [SMALL_STATE(289)] = 19044, + [SMALL_STATE(290)] = 19060, + [SMALL_STATE(291)] = 19074, + [SMALL_STATE(292)] = 19090, + [SMALL_STATE(293)] = 19106, + [SMALL_STATE(294)] = 19122, + [SMALL_STATE(295)] = 19138, + [SMALL_STATE(296)] = 19152, + [SMALL_STATE(297)] = 19166, + [SMALL_STATE(298)] = 19182, + [SMALL_STATE(299)] = 19196, + [SMALL_STATE(300)] = 19212, + [SMALL_STATE(301)] = 19226, + [SMALL_STATE(302)] = 19239, + [SMALL_STATE(303)] = 19252, + [SMALL_STATE(304)] = 19265, + [SMALL_STATE(305)] = 19278, + [SMALL_STATE(306)] = 19291, + [SMALL_STATE(307)] = 19300, + [SMALL_STATE(308)] = 19313, + [SMALL_STATE(309)] = 19326, + [SMALL_STATE(310)] = 19339, + [SMALL_STATE(311)] = 19352, + [SMALL_STATE(312)] = 19365, + [SMALL_STATE(313)] = 19378, + [SMALL_STATE(314)] = 19391, + [SMALL_STATE(315)] = 19402, + [SMALL_STATE(316)] = 19413, + [SMALL_STATE(317)] = 19424, + [SMALL_STATE(318)] = 19435, + [SMALL_STATE(319)] = 19448, + [SMALL_STATE(320)] = 19461, + [SMALL_STATE(321)] = 19474, + [SMALL_STATE(322)] = 19487, + [SMALL_STATE(323)] = 19498, + [SMALL_STATE(324)] = 19511, + [SMALL_STATE(325)] = 19524, + [SMALL_STATE(326)] = 19537, + [SMALL_STATE(327)] = 19550, + [SMALL_STATE(328)] = 19563, + [SMALL_STATE(329)] = 19576, + [SMALL_STATE(330)] = 19589, + [SMALL_STATE(331)] = 19600, + [SMALL_STATE(332)] = 19613, + [SMALL_STATE(333)] = 19626, + [SMALL_STATE(334)] = 19639, + [SMALL_STATE(335)] = 19652, + [SMALL_STATE(336)] = 19665, + [SMALL_STATE(337)] = 19675, + [SMALL_STATE(338)] = 19683, + [SMALL_STATE(339)] = 19693, + [SMALL_STATE(340)] = 19701, + [SMALL_STATE(341)] = 19709, + [SMALL_STATE(342)] = 19719, + [SMALL_STATE(343)] = 19727, + [SMALL_STATE(344)] = 19737, + [SMALL_STATE(345)] = 19745, + [SMALL_STATE(346)] = 19753, + [SMALL_STATE(347)] = 19763, + [SMALL_STATE(348)] = 19773, + [SMALL_STATE(349)] = 19783, + [SMALL_STATE(350)] = 19793, + [SMALL_STATE(351)] = 19803, + [SMALL_STATE(352)] = 19811, + [SMALL_STATE(353)] = 19818, + [SMALL_STATE(354)] = 19825, + [SMALL_STATE(355)] = 19832, + [SMALL_STATE(356)] = 19839, + [SMALL_STATE(357)] = 19846, + [SMALL_STATE(358)] = 19853, + [SMALL_STATE(359)] = 19860, + [SMALL_STATE(360)] = 19867, + [SMALL_STATE(361)] = 19874, + [SMALL_STATE(362)] = 19881, + [SMALL_STATE(363)] = 19888, + [SMALL_STATE(364)] = 19895, + [SMALL_STATE(365)] = 19902, + [SMALL_STATE(366)] = 19909, + [SMALL_STATE(367)] = 19916, + [SMALL_STATE(368)] = 19923, + [SMALL_STATE(369)] = 19930, + [SMALL_STATE(370)] = 19937, + [SMALL_STATE(371)] = 19944, + [SMALL_STATE(372)] = 19951, + [SMALL_STATE(373)] = 19958, + [SMALL_STATE(374)] = 19965, + [SMALL_STATE(375)] = 19972, + [SMALL_STATE(376)] = 19979, + [SMALL_STATE(377)] = 19986, + [SMALL_STATE(378)] = 19993, + [SMALL_STATE(379)] = 20000, + [SMALL_STATE(380)] = 20007, + [SMALL_STATE(381)] = 20014, + [SMALL_STATE(382)] = 20021, + [SMALL_STATE(383)] = 20028, + [SMALL_STATE(384)] = 20035, + [SMALL_STATE(385)] = 20042, +}; + +static const TSParseActionEntry ts_parse_actions[] = { + [0] = {.entry = {.count = 0, .reusable = false}}, + [1] = {.entry = {.count = 1, .reusable = false}}, RECOVER(), + [3] = {.entry = {.count = 1, .reusable = true}}, SHIFT_EXTRA(), + [5] = {.entry = {.count = 1, .reusable = false}}, SHIFT(165), + [7] = {.entry = {.count = 1, .reusable = false}}, SHIFT(189), + [9] = {.entry = {.count = 1, .reusable = true}}, SHIFT(189), + [11] = {.entry = {.count = 1, .reusable = false}}, SHIFT(338), + [13] = {.entry = {.count = 1, .reusable = false}}, SHIFT(305), + [15] = {.entry = {.count = 1, .reusable = true}}, SHIFT(240), + [17] = {.entry = {.count = 1, .reusable = true}}, SHIFT(14), + [19] = {.entry = {.count = 1, .reusable = true}}, SHIFT(65), + [21] = {.entry = {.count = 1, .reusable = false}}, SHIFT(27), + [23] = {.entry = {.count = 1, .reusable = false}}, SHIFT(203), + [25] = {.entry = {.count = 1, .reusable = true}}, SHIFT(203), + [27] = {.entry = {.count = 1, .reusable = false}}, SHIFT(376), + [29] = {.entry = {.count = 1, .reusable = false}}, SHIFT(260), + [31] = {.entry = {.count = 1, .reusable = false}}, SHIFT(261), + [33] = {.entry = {.count = 1, .reusable = false}}, SHIFT(29), + [35] = {.entry = {.count = 1, .reusable = false}}, SHIFT(30), + [37] = {.entry = {.count = 1, .reusable = true}}, SHIFT(232), + [39] = {.entry = {.count = 1, .reusable = true}}, SHIFT(313), + [41] = {.entry = {.count = 1, .reusable = true}}, SHIFT(287), + [43] = {.entry = {.count = 1, .reusable = true}}, SHIFT(280), + [45] = {.entry = {.count = 1, .reusable = true}}, SHIFT(370), + [47] = {.entry = {.count = 1, .reusable = false}}, SHIFT(106), + [49] = {.entry = {.count = 1, .reusable = false}}, SHIFT(149), + [51] = {.entry = {.count = 1, .reusable = true}}, SHIFT(149), + [53] = {.entry = {.count = 1, .reusable = false}}, SHIFT(348), + [55] = {.entry = {.count = 1, .reusable = false}}, SHIFT(309), + [57] = {.entry = {.count = 1, .reusable = true}}, SHIFT(239), + [59] = {.entry = {.count = 1, .reusable = true}}, SHIFT(15), + [61] = {.entry = {.count = 1, .reusable = true}}, SHIFT(128), + [63] = {.entry = {.count = 1, .reusable = true}}, SHIFT(80), + [65] = {.entry = {.count = 1, .reusable = false}}, SHIFT(46), + [67] = {.entry = {.count = 1, .reusable = false}}, SHIFT(382), + [69] = {.entry = {.count = 1, .reusable = false}}, SHIFT(259), + [71] = {.entry = {.count = 1, .reusable = false}}, SHIFT(262), + [73] = {.entry = {.count = 1, .reusable = false}}, SHIFT(50), + [75] = {.entry = {.count = 1, .reusable = false}}, SHIFT(343), + [77] = {.entry = {.count = 1, .reusable = true}}, SHIFT(123), + [79] = {.entry = {.count = 1, .reusable = true}}, SHIFT(303), + [81] = {.entry = {.count = 1, .reusable = true}}, SHIFT(276), + [83] = {.entry = {.count = 1, .reusable = true}}, SHIFT(275), + [85] = {.entry = {.count = 1, .reusable = true}}, SHIFT(378), + [87] = {.entry = {.count = 1, .reusable = true}}, SHIFT(211), + [89] = {.entry = {.count = 1, .reusable = false}}, SHIFT(125), + [91] = {.entry = {.count = 1, .reusable = true}}, SHIFT(125), + [93] = {.entry = {.count = 1, .reusable = true}}, SHIFT(202), + [95] = {.entry = {.count = 1, .reusable = true}}, SHIFT(104), + [97] = {.entry = {.count = 1, .reusable = false}}, SHIFT(179), + [99] = {.entry = {.count = 1, .reusable = true}}, SHIFT(179), + [101] = {.entry = {.count = 1, .reusable = true}}, SHIFT(224), + [103] = {.entry = {.count = 1, .reusable = true}}, SHIFT(18), + [105] = {.entry = {.count = 1, .reusable = false}}, SHIFT(174), + [107] = {.entry = {.count = 1, .reusable = true}}, SHIFT(174), + [109] = {.entry = {.count = 1, .reusable = true}}, SHIFT(142), + [111] = {.entry = {.count = 1, .reusable = true}}, SHIFT(20), + [113] = {.entry = {.count = 1, .reusable = false}}, SHIFT(166), + [115] = {.entry = {.count = 1, .reusable = true}}, SHIFT(166), + [117] = {.entry = {.count = 1, .reusable = true}}, SHIFT(219), + [119] = {.entry = {.count = 1, .reusable = true}}, SHIFT(22), + [121] = {.entry = {.count = 1, .reusable = false}}, SHIFT(177), + [123] = {.entry = {.count = 1, .reusable = true}}, SHIFT(177), + [125] = {.entry = {.count = 1, .reusable = true}}, SHIFT(115), + [127] = {.entry = {.count = 1, .reusable = true}}, SHIFT(7), + [129] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_args, 3), + [131] = {.entry = {.count = 1, .reusable = false}}, SHIFT(171), + [133] = {.entry = {.count = 1, .reusable = true}}, SHIFT(171), + [135] = {.entry = {.count = 1, .reusable = true}}, SHIFT(130), + [137] = {.entry = {.count = 1, .reusable = true}}, SHIFT(19), + [139] = {.entry = {.count = 1, .reusable = false}}, SHIFT(172), + [141] = {.entry = {.count = 1, .reusable = true}}, SHIFT(172), + [143] = {.entry = {.count = 1, .reusable = true}}, SHIFT(236), + [145] = {.entry = {.count = 1, .reusable = true}}, SHIFT(8), + [147] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_args, 2), + [149] = {.entry = {.count = 1, .reusable = false}}, SHIFT(103), + [151] = {.entry = {.count = 1, .reusable = true}}, SHIFT(103), + [153] = {.entry = {.count = 1, .reusable = true}}, SHIFT(221), + [155] = {.entry = {.count = 1, .reusable = false}}, SHIFT(105), + [157] = {.entry = {.count = 1, .reusable = true}}, SHIFT(105), + [159] = {.entry = {.count = 1, .reusable = true}}, SHIFT(138), + [161] = {.entry = {.count = 1, .reusable = false}}, SHIFT(187), + [163] = {.entry = {.count = 1, .reusable = true}}, SHIFT(187), + [165] = {.entry = {.count = 1, .reusable = true}}, SHIFT(119), + [167] = {.entry = {.count = 1, .reusable = false}}, SHIFT(188), + [169] = {.entry = {.count = 1, .reusable = true}}, SHIFT(188), + [171] = {.entry = {.count = 1, .reusable = true}}, SHIFT(237), + [173] = {.entry = {.count = 1, .reusable = false}}, SHIFT(191), + [175] = {.entry = {.count = 1, .reusable = true}}, SHIFT(191), + [177] = {.entry = {.count = 1, .reusable = true}}, SHIFT(231), + [179] = {.entry = {.count = 1, .reusable = false}}, SHIFT(193), + [181] = {.entry = {.count = 1, .reusable = true}}, SHIFT(193), + [183] = {.entry = {.count = 1, .reusable = true}}, SHIFT(121), + [185] = {.entry = {.count = 1, .reusable = false}}, SHIFT(190), + [187] = {.entry = {.count = 1, .reusable = true}}, SHIFT(190), + [189] = {.entry = {.count = 1, .reusable = true}}, SHIFT(133), + [191] = {.entry = {.count = 1, .reusable = false}}, SHIFT(182), + [193] = {.entry = {.count = 1, .reusable = true}}, SHIFT(182), + [195] = {.entry = {.count = 1, .reusable = true}}, SHIFT(235), + [197] = {.entry = {.count = 1, .reusable = false}}, SHIFT(98), + [199] = {.entry = {.count = 1, .reusable = true}}, SHIFT(98), + [201] = {.entry = {.count = 1, .reusable = false}}, SHIFT(84), + [203] = {.entry = {.count = 1, .reusable = true}}, SHIFT(84), + [205] = {.entry = {.count = 1, .reusable = false}}, SHIFT(175), + [207] = {.entry = {.count = 1, .reusable = true}}, SHIFT(175), + [209] = {.entry = {.count = 1, .reusable = false}}, SHIFT(184), + [211] = {.entry = {.count = 1, .reusable = true}}, SHIFT(184), + [213] = {.entry = {.count = 1, .reusable = false}}, SHIFT(134), + [215] = {.entry = {.count = 1, .reusable = true}}, SHIFT(134), + [217] = {.entry = {.count = 1, .reusable = false}}, SHIFT(162), + [219] = {.entry = {.count = 1, .reusable = true}}, SHIFT(162), + [221] = {.entry = {.count = 1, .reusable = false}}, SHIFT(132), + [223] = {.entry = {.count = 1, .reusable = true}}, SHIFT(132), + [225] = {.entry = {.count = 1, .reusable = false}}, SHIFT(154), + [227] = {.entry = {.count = 1, .reusable = true}}, SHIFT(154), + [229] = {.entry = {.count = 1, .reusable = false}}, SHIFT(167), + [231] = {.entry = {.count = 1, .reusable = true}}, SHIFT(167), + [233] = {.entry = {.count = 1, .reusable = false}}, SHIFT(192), + [235] = {.entry = {.count = 1, .reusable = true}}, SHIFT(192), + [237] = {.entry = {.count = 1, .reusable = false}}, SHIFT(181), + [239] = {.entry = {.count = 1, .reusable = true}}, SHIFT(181), + [241] = {.entry = {.count = 1, .reusable = false}}, SHIFT(170), + [243] = {.entry = {.count = 1, .reusable = true}}, SHIFT(170), + [245] = {.entry = {.count = 1, .reusable = false}}, SHIFT(153), + [247] = {.entry = {.count = 1, .reusable = true}}, SHIFT(153), + [249] = {.entry = {.count = 1, .reusable = false}}, SHIFT(169), + [251] = {.entry = {.count = 1, .reusable = true}}, SHIFT(169), + [253] = {.entry = {.count = 1, .reusable = false}}, SHIFT(89), + [255] = {.entry = {.count = 1, .reusable = true}}, SHIFT(89), + [257] = {.entry = {.count = 1, .reusable = false}}, SHIFT(94), + [259] = {.entry = {.count = 1, .reusable = true}}, SHIFT(94), + [261] = {.entry = {.count = 1, .reusable = false}}, SHIFT(178), + [263] = {.entry = {.count = 1, .reusable = true}}, SHIFT(178), + [265] = {.entry = {.count = 1, .reusable = false}}, SHIFT(86), + [267] = {.entry = {.count = 1, .reusable = true}}, SHIFT(86), + [269] = {.entry = {.count = 1, .reusable = false}}, SHIFT(151), + [271] = {.entry = {.count = 1, .reusable = true}}, SHIFT(151), + [273] = {.entry = {.count = 1, .reusable = false}}, SHIFT(147), + [275] = {.entry = {.count = 1, .reusable = true}}, SHIFT(147), + [277] = {.entry = {.count = 1, .reusable = false}}, SHIFT(135), + [279] = {.entry = {.count = 1, .reusable = true}}, SHIFT(135), + [281] = {.entry = {.count = 1, .reusable = false}}, SHIFT(185), + [283] = {.entry = {.count = 1, .reusable = true}}, SHIFT(185), + [285] = {.entry = {.count = 1, .reusable = false}}, SHIFT(93), + [287] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93), + [289] = {.entry = {.count = 1, .reusable = false}}, SHIFT(118), + [291] = {.entry = {.count = 1, .reusable = true}}, SHIFT(118), + [293] = {.entry = {.count = 1, .reusable = false}}, SHIFT(152), + [295] = {.entry = {.count = 1, .reusable = true}}, SHIFT(152), + [297] = {.entry = {.count = 1, .reusable = false}}, SHIFT(101), + [299] = {.entry = {.count = 1, .reusable = true}}, SHIFT(101), + [301] = {.entry = {.count = 1, .reusable = false}}, SHIFT(148), + [303] = {.entry = {.count = 1, .reusable = true}}, SHIFT(148), + [305] = {.entry = {.count = 1, .reusable = false}}, SHIFT(173), + [307] = {.entry = {.count = 1, .reusable = true}}, SHIFT(173), + [309] = {.entry = {.count = 1, .reusable = false}}, SHIFT(100), + [311] = {.entry = {.count = 1, .reusable = true}}, SHIFT(100), + [313] = {.entry = {.count = 1, .reusable = false}}, SHIFT(85), + [315] = {.entry = {.count = 1, .reusable = true}}, SHIFT(85), + [317] = {.entry = {.count = 1, .reusable = false}}, SHIFT(150), + [319] = {.entry = {.count = 1, .reusable = true}}, SHIFT(150), + [321] = {.entry = {.count = 1, .reusable = false}}, SHIFT(96), + [323] = {.entry = {.count = 1, .reusable = true}}, SHIFT(96), + [325] = {.entry = {.count = 1, .reusable = false}}, SHIFT(83), + [327] = {.entry = {.count = 1, .reusable = true}}, SHIFT(83), + [329] = {.entry = {.count = 1, .reusable = false}}, SHIFT(186), + [331] = {.entry = {.count = 1, .reusable = true}}, SHIFT(186), + [333] = {.entry = {.count = 1, .reusable = false}}, SHIFT(92), + [335] = {.entry = {.count = 1, .reusable = true}}, SHIFT(92), + [337] = {.entry = {.count = 1, .reusable = false}}, SHIFT(131), + [339] = {.entry = {.count = 1, .reusable = true}}, SHIFT(131), + [341] = {.entry = {.count = 1, .reusable = false}}, SHIFT(97), + [343] = {.entry = {.count = 1, .reusable = true}}, SHIFT(97), + [345] = {.entry = {.count = 1, .reusable = false}}, SHIFT(168), + [347] = {.entry = {.count = 1, .reusable = true}}, SHIFT(168), + [349] = {.entry = {.count = 1, .reusable = false}}, SHIFT(144), + [351] = {.entry = {.count = 1, .reusable = true}}, SHIFT(144), + [353] = {.entry = {.count = 1, .reusable = false}}, SHIFT(95), + [355] = {.entry = {.count = 1, .reusable = true}}, SHIFT(95), + [357] = {.entry = {.count = 1, .reusable = false}}, SHIFT(194), + [359] = {.entry = {.count = 1, .reusable = true}}, SHIFT(194), + [361] = {.entry = {.count = 1, .reusable = false}}, SHIFT(91), + [363] = {.entry = {.count = 1, .reusable = true}}, SHIFT(91), + [365] = {.entry = {.count = 1, .reusable = false}}, SHIFT(164), + [367] = {.entry = {.count = 1, .reusable = true}}, SHIFT(164), + [369] = {.entry = {.count = 1, .reusable = false}}, SHIFT(163), + [371] = {.entry = {.count = 1, .reusable = true}}, SHIFT(163), + [373] = {.entry = {.count = 1, .reusable = false}}, SHIFT(161), + [375] = {.entry = {.count = 1, .reusable = true}}, SHIFT(161), + [377] = {.entry = {.count = 1, .reusable = false}}, SHIFT(160), + [379] = {.entry = {.count = 1, .reusable = true}}, SHIFT(160), + [381] = {.entry = {.count = 1, .reusable = false}}, SHIFT(159), + [383] = {.entry = {.count = 1, .reusable = true}}, SHIFT(159), + [385] = {.entry = {.count = 1, .reusable = false}}, SHIFT(99), + [387] = {.entry = {.count = 1, .reusable = true}}, SHIFT(99), + [389] = {.entry = {.count = 1, .reusable = false}}, SHIFT(158), + [391] = {.entry = {.count = 1, .reusable = true}}, SHIFT(158), + [393] = {.entry = {.count = 1, .reusable = false}}, SHIFT(157), + [395] = {.entry = {.count = 1, .reusable = true}}, SHIFT(157), + [397] = {.entry = {.count = 1, .reusable = false}}, SHIFT(156), + [399] = {.entry = {.count = 1, .reusable = true}}, SHIFT(156), + [401] = {.entry = {.count = 1, .reusable = false}}, SHIFT(155), + [403] = {.entry = {.count = 1, .reusable = true}}, SHIFT(155), + [405] = {.entry = {.count = 1, .reusable = false}}, SHIFT(176), + [407] = {.entry = {.count = 1, .reusable = true}}, SHIFT(176), + [409] = {.entry = {.count = 1, .reusable = false}}, SHIFT(90), + [411] = {.entry = {.count = 1, .reusable = true}}, SHIFT(90), + [413] = {.entry = {.count = 1, .reusable = false}}, SHIFT(180), + [415] = {.entry = {.count = 1, .reusable = true}}, SHIFT(180), + [417] = {.entry = {.count = 1, .reusable = false}}, SHIFT(183), + [419] = {.entry = {.count = 1, .reusable = true}}, SHIFT(183), + [421] = {.entry = {.count = 1, .reusable = false}}, SHIFT(88), + [423] = {.entry = {.count = 1, .reusable = true}}, SHIFT(88), + [425] = {.entry = {.count = 1, .reusable = false}}, SHIFT(87), + [427] = {.entry = {.count = 1, .reusable = true}}, SHIFT(87), + [429] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binary, 3, .production_id = 7), + [431] = {.entry = {.count = 1, .reusable = true}}, SHIFT(9), + [433] = {.entry = {.count = 1, .reusable = true}}, SHIFT(336), + [435] = {.entry = {.count = 1, .reusable = true}}, SHIFT(5), + [437] = {.entry = {.count = 1, .reusable = true}}, SHIFT(201), + [439] = {.entry = {.count = 1, .reusable = false}}, SHIFT(201), + [441] = {.entry = {.count = 1, .reusable = true}}, SHIFT(210), + [443] = {.entry = {.count = 1, .reusable = true}}, SHIFT(209), + [445] = {.entry = {.count = 1, .reusable = false}}, SHIFT(208), + [447] = {.entry = {.count = 1, .reusable = true}}, SHIFT(208), + [449] = {.entry = {.count = 1, .reusable = true}}, SHIFT(207), + [451] = {.entry = {.count = 1, .reusable = true}}, SHIFT(205), + [453] = {.entry = {.count = 1, .reusable = false}}, SHIFT(24), + [455] = {.entry = {.count = 1, .reusable = true}}, SHIFT(56), + [457] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binary, 3, .production_id = 7), + [459] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__assert_expr, 3), + [461] = {.entry = {.count = 1, .reusable = false}}, SHIFT(57), + [463] = {.entry = {.count = 1, .reusable = true}}, SHIFT(59), + [465] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64), + [467] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_anonymous_function, 4, .production_id = 9), + [469] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unary, 2, .production_id = 2), + [471] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unary, 2, .production_id = 2), + [473] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_conditional, 6, .production_id = 15), + [475] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_conditional, 4, .production_id = 8), + [477] = {.entry = {.count = 1, .reusable = true}}, SHIFT(47), + [479] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_anonymous_function, 5, .production_id = 12), + [481] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_local_bind, 5), + [483] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_local_bind, 4), + [485] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_error, 2), + [487] = {.entry = {.count = 1, .reusable = true}}, SHIFT(124), + [489] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_functioncall, 4), + [491] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_functioncall, 4), + [493] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3), + [495] = {.entry = {.count = 1, .reusable = true}}, SHIFT(230), + [497] = {.entry = {.count = 1, .reusable = true}}, SHIFT(343), + [499] = {.entry = {.count = 1, .reusable = true}}, SHIFT(143), + [501] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_functioncall, 3), + [503] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_functioncall, 3), + [505] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2), + [507] = {.entry = {.count = 1, .reusable = true}}, SHIFT(110), + [509] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_id, 1), + [511] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_id, 1), + [513] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_in_super, 3), + [515] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_in_super, 3), + [517] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_indexing, 8), + [519] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_indexing, 8), + [521] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__string, 3, .production_id = 5), + [523] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__string, 3, .production_id = 5), + [525] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array, 3), + [527] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array, 3), + [529] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object, 3), + [531] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object, 3), + [533] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parenthesis, 3), + [535] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_parenthesis, 3), + [537] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_string, 1), + [539] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_string, 1), + [541] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_fieldaccess_super, 3), + [543] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_fieldaccess_super, 3), + [545] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_indexing, 3), + [547] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_indexing, 3), + [549] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__string, 3, .production_id = 3), + [551] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__string, 3, .production_id = 3), + [553] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_fieldaccess, 3, .production_id = 6), + [555] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_fieldaccess, 3, .production_id = 6), + [557] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ifspec, 2), + [559] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_indexing, 7), + [561] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_indexing, 7), + [563] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_indexing_super, 4), + [565] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_indexing_super, 4), + [567] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_indexing, 6), + [569] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_indexing, 6), + [571] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_forloop, 6), + [573] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_forloop, 6), + [575] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_number, 1), + [577] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_number, 1), + [579] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_functioncall, 5), + [581] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_functioncall, 5), + [583] = {.entry = {.count = 1, .reusable = true}}, SHIFT(13), + [585] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_args, 1), + [587] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object, 4), + [589] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object, 4), + [591] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_implicit_plus, 2), + [593] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_implicit_plus, 2), + [595] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array, 4), + [597] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array, 4), + [599] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_forloop, 4), + [601] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_forloop, 4), + [603] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_indexing, 5), + [605] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_indexing, 5), + [607] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_forspec, 4), + [609] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assert, 2), + [611] = {.entry = {.count = 1, .reusable = true}}, SHIFT(51), + [613] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array, 5), + [615] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array, 5), + [617] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bind, 5, .production_id = 13), + [619] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bind, 6, .production_id = 16), + [621] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_forloop, 5), + [623] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_forloop, 5), + [625] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object, 2), + [627] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object, 2), + [629] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array, 2), + [631] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array, 2), + [633] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import, 2), + [635] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import, 2), + [637] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_importstr, 2), + [639] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_importstr, 2), + [641] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__string, 4, .production_id = 10), + [643] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__string, 4, .production_id = 10), + [645] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_indexing, 4), + [647] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_indexing, 4), + [649] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bind, 3), + [651] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__string, 2, .production_id = 1), + [653] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__string, 2, .production_id = 1), + [655] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object, 5), + [657] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object, 5), + [659] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field, 6, .production_id = 14), + [661] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assert, 4), + [663] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_array_repeat1, 2), + [665] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field, 3), + [667] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field, 4), + [669] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field, 5, .production_id = 14), + [671] = {.entry = {.count = 1, .reusable = true}}, SHIFT(12), + [673] = {.entry = {.count = 1, .reusable = true}}, SHIFT(341), + [675] = {.entry = {.count = 1, .reusable = true}}, SHIFT(4), + [677] = {.entry = {.count = 1, .reusable = true}}, SHIFT(40), + [679] = {.entry = {.count = 1, .reusable = true}}, SHIFT(206), + [681] = {.entry = {.count = 1, .reusable = false}}, SHIFT(67), + [683] = {.entry = {.count = 1, .reusable = true}}, SHIFT(68), + [685] = {.entry = {.count = 1, .reusable = false}}, SHIFT(69), + [687] = {.entry = {.count = 1, .reusable = true}}, SHIFT(70), + [689] = {.entry = {.count = 1, .reusable = true}}, SHIFT(71), + [691] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument, 3), + [693] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_param, 3, .production_id = 11), + [695] = {.entry = {.count = 1, .reusable = true}}, SHIFT(16), + [697] = {.entry = {.count = 1, .reusable = true}}, SHIFT(6), + [699] = {.entry = {.count = 1, .reusable = true}}, SHIFT(11), + [701] = {.entry = {.count = 1, .reusable = true}}, SHIFT(17), + [703] = {.entry = {.count = 1, .reusable = true}}, SHIFT(269), + [705] = {.entry = {.count = 1, .reusable = true}}, SHIFT(112), + [707] = {.entry = {.count = 1, .reusable = true}}, SHIFT(36), + [709] = {.entry = {.count = 1, .reusable = true}}, SHIFT(39), + [711] = {.entry = {.count = 1, .reusable = true}}, SHIFT(120), + [713] = {.entry = {.count = 1, .reusable = true}}, SHIFT(108), + [715] = {.entry = {.count = 1, .reusable = true}}, SHIFT(238), + [717] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_document, 1), + [719] = {.entry = {.count = 1, .reusable = true}}, SHIFT(229), + [721] = {.entry = {.count = 1, .reusable = true}}, SHIFT(217), + [723] = {.entry = {.count = 1, .reusable = true}}, SHIFT(223), + [725] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_multiplicative, 1), + [727] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_multiplicative, 1), + [729] = {.entry = {.count = 1, .reusable = true}}, SHIFT(220), + [731] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unaryop, 1), + [733] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unaryop, 1), + [735] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__expr, 1), + [737] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__expr, 1), + [739] = {.entry = {.count = 1, .reusable = false}}, SHIFT(31), + [741] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_equality, 1), + [743] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_equality, 1), + [745] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_comparison, 1), + [747] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_comparison, 1), + [749] = {.entry = {.count = 1, .reusable = false}}, SHIFT(226), + [751] = {.entry = {.count = 1, .reusable = false}}, SHIFT(107), + [753] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bitshift, 1), + [755] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bitshift, 1), + [757] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_additive, 1), + [759] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_additive, 1), + [761] = {.entry = {.count = 1, .reusable = false}}, SHIFT(329), + [763] = {.entry = {.count = 1, .reusable = true}}, SHIFT(137), + [765] = {.entry = {.count = 1, .reusable = true}}, SHIFT(34), + [767] = {.entry = {.count = 1, .reusable = true}}, SHIFT(222), + [769] = {.entry = {.count = 1, .reusable = true}}, SHIFT(146), + [771] = {.entry = {.count = 1, .reusable = true}}, SHIFT(225), + [773] = {.entry = {.count = 1, .reusable = true}}, SHIFT(218), + [775] = {.entry = {.count = 1, .reusable = true}}, SHIFT(126), + [777] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_objforloop_repeat1, 2), + [779] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_objforloop_repeat1, 2), SHIFT_REPEAT(329), + [782] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_objforloop_repeat1, 2), + [784] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_objforloop, 2), + [786] = {.entry = {.count = 1, .reusable = true}}, SHIFT(48), + [788] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_compspec, 1), + [790] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_objforloop, 3), + [792] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_objforloop, 4), + [794] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_compspec_repeat1, 2), + [796] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_compspec_repeat1, 2), SHIFT_REPEAT(48), + [799] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_compspec_repeat1, 2), SHIFT_REPEAT(343), + [802] = {.entry = {.count = 1, .reusable = true}}, SHIFT(215), + [804] = {.entry = {.count = 1, .reusable = true}}, SHIFT(233), + [806] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_objforloop, 5), + [808] = {.entry = {.count = 1, .reusable = true}}, SHIFT(136), + [810] = {.entry = {.count = 1, .reusable = true}}, SHIFT(129), + [812] = {.entry = {.count = 1, .reusable = true}}, SHIFT(165), + [814] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42), + [816] = {.entry = {.count = 1, .reusable = true}}, SHIFT(374), + [818] = {.entry = {.count = 1, .reusable = true}}, SHIFT(330), + [820] = {.entry = {.count = 1, .reusable = true}}, SHIFT(26), + [822] = {.entry = {.count = 1, .reusable = false}}, SHIFT(55), + [824] = {.entry = {.count = 1, .reusable = true}}, SHIFT(265), + [826] = {.entry = {.count = 1, .reusable = true}}, SHIFT(317), + [828] = {.entry = {.count = 1, .reusable = true}}, SHIFT(55), + [830] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_fieldname, 1), + [832] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_fieldname, 1), + [834] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_fieldname, 3), + [836] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_fieldname, 3), + [838] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_member, 1), + [840] = {.entry = {.count = 1, .reusable = false}}, SHIFT_EXTRA(), + [842] = {.entry = {.count = 1, .reusable = false}}, SHIFT(196), + [844] = {.entry = {.count = 1, .reusable = true}}, SHIFT(314), + [846] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_array_repeat1, 2), SHIFT_REPEAT(41), + [849] = {.entry = {.count = 1, .reusable = false}}, SHIFT(109), + [851] = {.entry = {.count = 1, .reusable = true}}, SHIFT(315), + [853] = {.entry = {.count = 1, .reusable = false}}, SHIFT(145), + [855] = {.entry = {.count = 1, .reusable = true}}, SHIFT(10), + [857] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__str_double, 2), + [859] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__str_double, 2), SHIFT_REPEAT(314), + [862] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__str_single, 2), + [864] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__str_single, 2), SHIFT_REPEAT(315), + [867] = {.entry = {.count = 1, .reusable = false}}, SHIFT(198), + [869] = {.entry = {.count = 1, .reusable = true}}, SHIFT(284), + [871] = {.entry = {.count = 1, .reusable = true}}, SHIFT(329), + [873] = {.entry = {.count = 1, .reusable = false}}, SHIFT(116), + [875] = {.entry = {.count = 1, .reusable = false}}, SHIFT(197), + [877] = {.entry = {.count = 1, .reusable = true}}, SHIFT(291), + [879] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_params, 3), + [881] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_args, 4), + [883] = {.entry = {.count = 1, .reusable = false}}, SHIFT(141), + [885] = {.entry = {.count = 1, .reusable = false}}, SHIFT(199), + [887] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_params, 2), + [889] = {.entry = {.count = 1, .reusable = true}}, SHIFT(308), + [891] = {.entry = {.count = 1, .reusable = true}}, SHIFT(62), + [893] = {.entry = {.count = 1, .reusable = true}}, SHIFT(53), + [895] = {.entry = {.count = 1, .reusable = true}}, SHIFT(274), + [897] = {.entry = {.count = 1, .reusable = true}}, SHIFT(273), + [899] = {.entry = {.count = 1, .reusable = true}}, SHIFT(385), + [901] = {.entry = {.count = 1, .reusable = true}}, SHIFT(242), + [903] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_objlocal, 2), + [905] = {.entry = {.count = 1, .reusable = true}}, SHIFT(52), + [907] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_params_repeat1, 2), SHIFT_REPEAT(320), + [910] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_params_repeat1, 2), + [912] = {.entry = {.count = 1, .reusable = true}}, SHIFT(282), + [914] = {.entry = {.count = 1, .reusable = true}}, SHIFT(292), + [916] = {.entry = {.count = 1, .reusable = true}}, SHIFT(288), + [918] = {.entry = {.count = 1, .reusable = true}}, SHIFT(290), + [920] = {.entry = {.count = 1, .reusable = true}}, SHIFT(372), + [922] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__str_double, 1), + [924] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__str_double, 1), + [926] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__str_single, 1), + [928] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__str_single, 1), + [930] = {.entry = {.count = 1, .reusable = false}}, SHIFT(44), + [932] = {.entry = {.count = 1, .reusable = true}}, SHIFT(44), + [934] = {.entry = {.count = 1, .reusable = false}}, SHIFT(43), + [936] = {.entry = {.count = 1, .reusable = true}}, SHIFT(43), + [938] = {.entry = {.count = 1, .reusable = true}}, SHIFT(294), + [940] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_args_repeat1, 2), SHIFT_REPEAT(324), + [943] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_args_repeat1, 2), + [945] = {.entry = {.count = 1, .reusable = true}}, SHIFT(23), + [947] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_param, 1, .production_id = 4), + [949] = {.entry = {.count = 1, .reusable = true}}, SHIFT(37), + [951] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21), + [953] = {.entry = {.count = 1, .reusable = true}}, SHIFT(297), + [955] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_params, 1), + [957] = {.entry = {.count = 1, .reusable = true}}, SHIFT(241), + [959] = {.entry = {.count = 1, .reusable = true}}, SHIFT(72), + [961] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_objforloop_repeat2, 2), SHIFT_REPEAT(350), + [964] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_objforloop_repeat2, 2), + [966] = {.entry = {.count = 1, .reusable = false}}, SHIFT(49), + [968] = {.entry = {.count = 1, .reusable = true}}, SHIFT(49), + [970] = {.entry = {.count = 1, .reusable = true}}, SHIFT(299), + [972] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_local_bind_repeat1, 2), SHIFT_REPEAT(308), + [975] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_local_bind_repeat1, 2), + [977] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_objinside_repeat1, 2), + [979] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_objinside_repeat1, 2), SHIFT_REPEAT(245), + [982] = {.entry = {.count = 1, .reusable = true}}, SHIFT(228), + [984] = {.entry = {.count = 1, .reusable = true}}, SHIFT(243), + [986] = {.entry = {.count = 1, .reusable = true}}, SHIFT(111), + [988] = {.entry = {.count = 1, .reusable = true}}, SHIFT(244), + [990] = {.entry = {.count = 1, .reusable = true}}, SHIFT(106), + [992] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33), + [994] = {.entry = {.count = 1, .reusable = true}}, SHIFT(347), + [996] = {.entry = {.count = 1, .reusable = true}}, SHIFT(58), + [998] = {.entry = {.count = 1, .reusable = true}}, SHIFT(346), + [1000] = {.entry = {.count = 1, .reusable = true}}, SHIFT(264), + [1002] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63), + [1004] = {.entry = {.count = 1, .reusable = true}}, SHIFT(196), + [1006] = {.entry = {.count = 1, .reusable = true}}, SHIFT(253), + [1008] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54), + [1010] = {.entry = {.count = 1, .reusable = true}}, SHIFT(316), + [1012] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_objforloop, 6), + [1014] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61), + [1016] = {.entry = {.count = 1, .reusable = true}}, SHIFT(141), + [1018] = {.entry = {.count = 1, .reusable = true}}, SHIFT(35), + [1020] = {.entry = {.count = 1, .reusable = true}}, SHIFT(116), + [1022] = {.entry = {.count = 1, .reusable = true}}, SHIFT(199), + [1024] = {.entry = {.count = 1, .reusable = true}}, SHIFT(102), + [1026] = {.entry = {.count = 1, .reusable = true}}, SHIFT(31), + [1028] = {.entry = {.count = 1, .reusable = true}}, SHIFT(79), + [1030] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), + [1032] = {.entry = {.count = 1, .reusable = true}}, SHIFT(200), + [1034] = {.entry = {.count = 1, .reusable = true}}, SHIFT(362), + [1036] = {.entry = {.count = 1, .reusable = true}}, SHIFT(122), + [1038] = {.entry = {.count = 1, .reusable = true}}, SHIFT(352), + [1040] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28), + [1042] = {.entry = {.count = 1, .reusable = true}}, SHIFT(379), + [1044] = {.entry = {.count = 1, .reusable = true}}, SHIFT(266), + [1046] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60), + [1048] = {.entry = {.count = 1, .reusable = true}}, SHIFT(361), + [1050] = {.entry = {.count = 1, .reusable = true}}, SHIFT(45), + [1052] = {.entry = {.count = 1, .reusable = true}}, SHIFT(213), + [1054] = {.entry = {.count = 1, .reusable = true}}, SHIFT(263), + [1056] = {.entry = {.count = 1, .reusable = true}}, SHIFT(358), +}; + +#ifdef __cplusplus +extern "C" { +#endif +void *tree_sitter_jsonnet_external_scanner_create(void); +void tree_sitter_jsonnet_external_scanner_destroy(void *); +bool tree_sitter_jsonnet_external_scanner_scan(void *, TSLexer *, const bool *); +unsigned tree_sitter_jsonnet_external_scanner_serialize(void *, char *); +void tree_sitter_jsonnet_external_scanner_deserialize(void *, const char *, unsigned); + +#ifdef _WIN32 +#define extern __declspec(dllexport) +#endif + +extern const TSLanguage *tree_sitter_jsonnet(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__ident, + .external_scanner = { + &ts_external_scanner_states[0][0], + ts_external_scanner_symbol_map, + tree_sitter_jsonnet_external_scanner_create, + tree_sitter_jsonnet_external_scanner_destroy, + tree_sitter_jsonnet_external_scanner_scan, + tree_sitter_jsonnet_external_scanner_serialize, + tree_sitter_jsonnet_external_scanner_deserialize, + }, + .primary_state_ids = ts_primary_state_ids, + }; + return &language; +} +#ifdef __cplusplus +} +#endif diff --git a/vendored_parsers/tree-sitter-jsonnet/src/scanner.c b/vendored_parsers/tree-sitter-jsonnet/src/scanner.c new file mode 100644 index 0000000000..8c146367dc --- /dev/null +++ b/vendored_parsers/tree-sitter-jsonnet/src/scanner.c @@ -0,0 +1,176 @@ +// https://github.com/Azganoth/tree-sitter-lua/blob/master/src/scanner.cc +// https://github.com/MunifTanjim/tree-sitter-lua/ +// and now here + +#include +#include +#include "tree_sitter/parser.h" + +enum TokenType { + STRING_START, + STRING_CONTENT, + 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); + } +} + +void *tree_sitter_jsonnet_external_scanner_create() { return NULL; } +void tree_sitter_jsonnet_external_scanner_destroy(void *payload) {} + +enum InsideNode { INSIDE_NONE, INSIDE_STRING }; + +uint8_t inside_node = INSIDE_NONE; +char ending_char = 0; +uint8_t level_count = 0; + +static inline void reset_state() { + inside_node = INSIDE_NONE; + ending_char = 0; + level_count = 0; +} + +unsigned tree_sitter_jsonnet_external_scanner_serialize(void *payload, char *buffer) { + buffer[0] = inside_node; + buffer[1] = ending_char; + buffer[2] = level_count; + return 3; +} + +void tree_sitter_jsonnet_external_scanner_deserialize(void *payload, const char *buffer, unsigned length) { + if (length == 0) return; + inside_node = buffer[0]; + if (length == 1) return; + ending_char = buffer[1]; + if (length == 2) return; + level_count = buffer[2]; +} + +static bool scan_block_start(TSLexer *lexer) { + if (consume_char('|', lexer) && consume_char('|', lexer) && consume_char('|', lexer)) { + return true; + } + + return false; +} + +static bool scan_block_end(TSLexer *lexer) { + if (consume_char('|', lexer) && consume_char('|', lexer) && consume_char('|', lexer)) { + return true; + } + + return false; +} + +static bool scan_block_content(TSLexer *lexer) { + while (lexer->lookahead != 0) { + if (lexer->lookahead == '|') { + lexer->mark_end(lexer); + + if (scan_block_end(lexer)) { + return true; + } + } else { + consume(lexer); + } + } + + return false; +} + +static bool scan_string_start(TSLexer *lexer) { + if (lexer->lookahead == '"' || lexer->lookahead == '\'') { + inside_node = INSIDE_STRING; + ending_char = lexer->lookahead; + consume(lexer); + return true; + } + + if (scan_block_start(lexer)) { + inside_node = INSIDE_STRING; + return true; + } + + return false; +} + +static bool scan_string_end(TSLexer *lexer) { + if (ending_char == 0) { // block string + return scan_block_end(lexer); + } + + if (consume_char(ending_char, lexer)) { + return true; + } + + return false; +} + +static bool scan_string_content(TSLexer *lexer) { + if (ending_char == 0) { // block string + return scan_block_content(lexer); + } + + while (lexer->lookahead != '\n' && lexer->lookahead != 0 && lexer->lookahead != ending_char) { + while (consume_char('\\', lexer) && consume_char('z', lexer)) continue; + + if (lexer->lookahead == 0) { + return true; + } + + consume(lexer); + } + + return true; +} + +bool tree_sitter_jsonnet_external_scanner_scan(void *payload, TSLexer *lexer, const bool *valid_symbols) { + if (inside_node == INSIDE_STRING) { + if (valid_symbols[STRING_END] && scan_string_end(lexer)) { + reset_state(); + lexer->result_symbol = STRING_END; + return true; + } + + if (valid_symbols[STRING_CONTENT] && scan_string_content(lexer)) { + lexer->result_symbol = STRING_CONTENT; + return true; + } + + return false; + } + + skip_whitespaces(lexer); + + if (valid_symbols[STRING_START] && scan_string_start(lexer)) { + lexer->result_symbol = STRING_START; + return true; + } + + + return false; +} diff --git a/vendored_parsers/tree-sitter-jsonnet/src/tree_sitter/parser.h b/vendored_parsers/tree-sitter-jsonnet/src/tree_sitter/parser.h new file mode 100644 index 0000000000..2b14ac1046 --- /dev/null +++ b/vendored_parsers/tree-sitter-jsonnet/src/tree_sitter/parser.h @@ -0,0 +1,224 @@ +#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 + +typedef uint16_t TSStateId; + +#ifndef TREE_SITTER_API_H_ +typedef uint16_t TSSymbol; +typedef uint16_t TSFieldId; +typedef struct TSLanguage TSLanguage; +#endif + +typedef struct { + TSFieldId field_id; + uint8_t child_index; + bool inherited; +} TSFieldMapEntry; + +typedef struct { + uint16_t index; + uint16_t length; +} TSFieldMapSlice; + +typedef struct { + bool visible; + bool named; + bool supertype; +} TSSymbolMetadata; + +typedef struct TSLexer TSLexer; + +struct TSLexer { + int32_t lookahead; + TSSymbol result_symbol; + void (*advance)(TSLexer *, bool); + void (*mark_end)(TSLexer *); + uint32_t (*get_column)(TSLexer *); + bool (*is_at_included_range_start)(const TSLexer *); + bool (*eof)(const TSLexer *); +}; + +typedef enum { + TSParseActionTypeShift, + TSParseActionTypeReduce, + TSParseActionTypeAccept, + TSParseActionTypeRecover, +} TSParseActionType; + +typedef union { + struct { + uint8_t type; + TSStateId state; + bool extra; + bool repetition; + } shift; + struct { + uint8_t type; + uint8_t child_count; + TSSymbol symbol; + int16_t dynamic_precedence; + uint16_t production_id; + } reduce; + uint8_t type; +} TSParseAction; + +typedef struct { + uint16_t lex_state; + uint16_t external_lex_state; +} TSLexMode; + +typedef union { + TSParseAction action; + struct { + uint8_t count; + bool reusable; + } entry; +} TSParseActionEntry; + +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; +}; + +/* + * Lexer Macros + */ + +#define START_LEXER() \ + bool result = false; \ + bool skip = false; \ + 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 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_val, child_count_val, ...) \ + {{ \ + .reduce = { \ + .type = TSParseActionTypeReduce, \ + .symbol = symbol_val, \ + .child_count = child_count_val, \ + __VA_ARGS__ \ + }, \ + }} + +#define RECOVER() \ + {{ \ + .type = TSParseActionTypeRecover \ + }} + +#define ACCEPT_INPUT() \ + {{ \ + .type = TSParseActionTypeAccept \ + }} + +#ifdef __cplusplus +} +#endif + +#endif // TREE_SITTER_PARSER_H_ diff --git a/vendored_parsers/tree-sitter-jsonnet/test/corpus/assert.txt b/vendored_parsers/tree-sitter-jsonnet/test/corpus/assert.txt new file mode 100644 index 0000000000..6b614d8646 --- /dev/null +++ b/vendored_parsers/tree-sitter-jsonnet/test/corpus/assert.txt @@ -0,0 +1,36 @@ +=== +Assert at root +=== + +assert true : 'message'; +{} + +--- + +(document + (assert + (true) + (string + (string_start) + (string_content) + (string_end))) + (object)) +=== +Assert in object +=== + +{ + assert true : 'message' +} + +--- + +(document + (object + (member + (assert + (true) + (string + (string_start) + (string_content) + (string_end)))))) diff --git a/vendored_parsers/tree-sitter-jsonnet/test/corpus/exprs.txt b/vendored_parsers/tree-sitter-jsonnet/test/corpus/exprs.txt new file mode 100644 index 0000000000..37818b24ca --- /dev/null +++ b/vendored_parsers/tree-sitter-jsonnet/test/corpus/exprs.txt @@ -0,0 +1,270 @@ +====================== +Indexing priority +====================== + +"Hello" + xxx.name + +--- + +(document + (binary + left: (string (string_start) (string_content) (string_end)) + operator: (additive) + right: (fieldaccess (id) last: (id)) + )) + +====================== +Indexing priority 2 +====================== + +"Hello" + xxx[name] + +--- + +(document + (binary + left: (string (string_start) (string_content) (string_end)) + operator: (additive) + right: (indexing (id) (id)) + )) + +====================== +Indexing priority 3 +====================== + +"Hello" + super.name + +--- + +(document + (binary + left: (string (string_start) (string_content) (string_end)) + operator: (additive) + right: (fieldaccess_super (super) (id)) + )) + +====================== +Indexing priority 4 +====================== + +"Hello" + super['name'] + +--- + +(document + (binary + left: (string (string_start) (string_content) (string_end)) + operator: (additive) + right: (indexing_super + (super) + (string + (string_start) + (string_content) + (string_end))) + )) + +====================== +Parses example 2 +====================== + +{ + person1: { + name: "Alice", + welcome: "Hello " + self.name + "!", + }, + person2: self.person1 { name: "Bob" }, +} + +--- +(document + (object + (member + (field (fieldname (id)) + (object + (member + (field (fieldname (id)) + (string (string_start) (string_content) (string_end)) + )) + (member + (field (fieldname (id)) + (binary + left: + (binary + left: (string (string_start) (string_content) (string_end)) + operator: (additive) + right: (fieldaccess (self) last: (id))) + operator: (additive) + right: (string (string_start) (string_content) (string_end)) + ))) + ))) + (member + (field (fieldname (id)) + (implicit_plus + (fieldaccess (self) last: (id)) + (object + (member + (field (fieldname (id)) + (string (string_start) (string_content) (string_end)) + )))))))) + +================================= +should parse basic call foo(1,2) +================================= + +{ + x1: foo(1,2) +} + +--- + +(document + (object + (member (field (fieldname (id)) + (functioncall + (id) + (args (number) + (number))) +)))) + +================================= +should parse basic call foo(1,2,3) +================================= + +{ + x1: foo(1,2,3) +} + +--- + +(document + (object + (member (field (fieldname (id)) + (functioncall + (id) + (args (number) + (number) + (number))) +)))) + +================================= +should parse tailstrict +================================= + +{ + x1: foo(1,2,3) tailstrict +} + +--- + +(document + (object + (member (field (fieldname (id)) + (functioncall + (id) + (args (number) + (number) + (number)) + (tailstrict)) +)))) + +================================= +should parse if-then-else +================================= + +if x > 0 then x + 2 else x - 2 + +--- +(document + (conditional + condition: + (binary + left: (id) + operator: (comparison) + right: (number)) + consequence: + (binary + left: (id) + operator: (additive) + right: (number)) + alternative: + (binary + left: (id) + operator: (additive) + right: (number)))) + +================================= +if-then-else vs local priority +================================= + +local a = if x > 0 then x + 2 else x - 2; a + 2 + +--- +(document + (local_bind + (local) + (bind (id) + (conditional + condition: + (binary + left: (id) + operator: (comparison) + right: (number)) + consequence: + (binary + left: (id) + operator: (additive) + right: (number)) + alternative: + (binary + left: (id) + operator: (additive) + right: (number)) + )) + (binary + left: (id) + operator: (additive) + right: (number)))) + +================================= +operator precedence +================================= +3 + 4 * true + +--- + +(document + (binary + left: (number) + operator: (additive) + right: + (binary + left: (number) + operator: (multiplicative) + right: (true)))) + +====================== +Application priority +====================== + +!foo(2, 3) + +--- +(document + (unary + operator: (unaryop) + argument: (functioncall + (id) + (args (number) (number))))) + +====================== +Implicit plus with empty object +====================== + +({}) { } + +--- + +(document + (implicit_plus + (parenthesis (object)) + (object))) diff --git a/vendored_parsers/tree-sitter-jsonnet/test/corpus/fieldname.txt b/vendored_parsers/tree-sitter-jsonnet/test/corpus/fieldname.txt new file mode 100644 index 0000000000..724522da72 --- /dev/null +++ b/vendored_parsers/tree-sitter-jsonnet/test/corpus/fieldname.txt @@ -0,0 +1,137 @@ +=============================== +Resolve expr in fieldname key 1 +=============================== + +local a = 'a'; +{ [a]: 'a' } + +--- + +(document + (local_bind + (local) + (bind + (id) + (string + (string_start) + (string_content) + (string_end))) + (object + (member + (field + (fieldname (id)) + (string + (string_start) + (string_content) + (string_end))))))) + +=============================== +Resolve expr in fieldname key 2 +=============================== + +local prefix = 'Happy Hour '; +{ + [prefix + 'Mimosa']: 'Champagne', +} + +--- + +(document + (local_bind + (local) + (bind + (id) + (string + (string_start) + (string_content) + (string_end))) + (object + (member + (field + (fieldname + (binary + (id) + (additive) + (string + (string_start) + (string_content) + (string_end)))) + (string + (string_start) + (string_content) + (string_end))))))) + +=============================== +Resolve expr in fieldname key 3 +=============================== + +local Margarita(salted) = { + [if salted then 'garnish']: 'Salt', + ingredients: [ + { kind: 'Tequila Blanco', qty: 2 }, + ], +}; +{ + Margarita: Margarita(true), + 'Margarita Unsalted': Margarita(false), +} + +--- + +(document + (local_bind + (local) + (bind + function: (id) + params: + (params + (param + identifier: (id))) + body: (object + (member + (field + (fieldname + (conditional + condition: (id) + consequence: + (string + (string_start) + (string_content) + (string_end)))) + (string + (string_start) + (string_content) + (string_end)))) + (member + (field + (fieldname (id)) + (array + (object + (member + (field + (fieldname (id)) + (string + (string_start) + (string_content) + (string_end)))) + (member + (field + (fieldname (id)) + (number))))))))) + (object + (member + (field + (fieldname (id)) + (functioncall + (id) + (args (true))))) + (member + (field + (fieldname + (string + (string_start) + (string_content) + (string_end))) + (functioncall + (id) + (args (false)))))))) diff --git a/vendored_parsers/tree-sitter-jsonnet/test/corpus/forloop.txt b/vendored_parsers/tree-sitter-jsonnet/test/corpus/forloop.txt new file mode 100644 index 0000000000..c1c8947585 --- /dev/null +++ b/vendored_parsers/tree-sitter-jsonnet/test/corpus/forloop.txt @@ -0,0 +1,86 @@ +====================== +For loop in array +====================== + +[ + i + for i in std.range(0,10) +] + +--- + +(document + (forloop + (id) + (forspec + (id) + (functioncall + (fieldaccess (id) last: (id)) + (args (number) (number)))))) + +====================== +For loop in object +====================== + +{ + ['item' + i]: i + for i in std.range(0,10) +} + +--- + +(document + (object + (objforloop + (field + (fieldname + (binary + left: + (string + (string_start) + (string_content) + (string_end)) + operator: (additive) + right: (id))) + (id)) + (forspec + (id) + (functioncall + (fieldaccess (id) last: (id)) + (args (number) (number))))))) + +================================ +For loop in object with function +================================ + +{ + ['item' + i](v): i + v + for i in std.range(0,10) +} + +--- + +(document + (object + (objforloop + (field + function: (fieldname + (binary + left: (string + (string_start) + (string_content) + (string_end)) + operator: (additive) + right: (id))) + (params + (param + identifier: (id))) + (binary + left: (id) + operator: (additive) + right: (id))) + (forspec + (id) + (functioncall + (fieldaccess (id) last: (id)) + (args (number) (number))))))) diff --git a/vendored_parsers/tree-sitter-jsonnet/test/corpus/inoperator.txt b/vendored_parsers/tree-sitter-jsonnet/test/corpus/inoperator.txt new file mode 100644 index 0000000000..cae541ea06 --- /dev/null +++ b/vendored_parsers/tree-sitter-jsonnet/test/corpus/inoperator.txt @@ -0,0 +1,59 @@ +====================== +In operator on object +====================== + +local obj = { a: null }; +'a' in obj + +--- + +(document + (local_bind + (local) + (bind + (id) + (object + (member + (field + (fieldname (id)) + (null))))) + (binary + (string + (string_start) + (string_content) + (string_end)) + (comparison) + (id)))) + +====================== +In operator on super +====================== + +local obj = { a: null }; +obj + { b: 'a' in super } + +--- + +(document + (local_bind + (local) + (bind + (id) + (object + (member + (field + (fieldname (id)) + (null))))) + (binary + (id) + (additive) + (object + (member + (field + (fieldname (id)) + (in_super + (string + (string_start) + (string_content) + (string_end)) + (super)))))))) diff --git a/vendored_parsers/tree-sitter-jsonnet/test/corpus/number.txt b/vendored_parsers/tree-sitter-jsonnet/test/corpus/number.txt new file mode 100644 index 0000000000..7cb2271af8 --- /dev/null +++ b/vendored_parsers/tree-sitter-jsonnet/test/corpus/number.txt @@ -0,0 +1,43 @@ +====================== +should parse literal 0 +====================== + +0 + +--- + +(document + (number)) + +====================== +should parse literal 1 +====================== + +1 + +--- + +(document + (number)) + +========================= +should parse literal 3.14 +========================= + +3.14 + +--- + +(document + (number)) + +============================ +should parse literal 1.23e10 +============================ + +1.23e10 + +--- + +(document + (number)) diff --git a/vendored_parsers/tree-sitter-jsonnet/test/corpus/objlocal.txt b/vendored_parsers/tree-sitter-jsonnet/test/corpus/objlocal.txt new file mode 100644 index 0000000000..e4f53cdbba --- /dev/null +++ b/vendored_parsers/tree-sitter-jsonnet/test/corpus/objlocal.txt @@ -0,0 +1,55 @@ +====================== +Parses example 1 +====================== + + +local Mojito(virgin=false, large=false) = { + // A local next to fields ends with ','. + local factor = if large then 2 else 1, + // The ingredients are split into 3 arrays, + // the middle one is either length 1 or 0. + ingredients: [], +}; + +{ + Mojito: Mojito(), +} + +--- + + +(document + (local_bind + (local) + (bind + function: (id) + params: (params + (param + identifier: (id) + value: (false)) + (param + identifier: (id) + value: (false))) + body: (object + (comment) + (member + (objlocal + (local) + (bind + (id) + (conditional + condition: (id) + consequence: (number) + alternative: (number))))) + (comment) + (comment) + (member + (field + (fieldname (id)) + (array))))) + (object + (member + (field + (fieldname (id)) + (functioncall + (id)))))))